From 6d4017244d4d8aa2e44b974a1f238ca185ee4ce9 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Fri, 23 Feb 2024 17:20:28 +0100 Subject: [PATCH 01/24] initial commit --- src/nodeConfigBuilder.ts | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 src/nodeConfigBuilder.ts diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts new file mode 100644 index 00000000..653898ed --- /dev/null +++ b/src/nodeConfigBuilder.ts @@ -0,0 +1,38 @@ +import { NodeConfig } from './types/NodeConfig.generated'; + +// todo: generate with ts-morph +// todo: is there a way to make jsdoc readable when working with the builder? +type NodeConfigParams = + | { + key: 'auth.addr'; + type: string; + } + | { + key: 'auth.api'; + type: string[]; + }; + +type NodeConfigKey = NodeConfigParams['key']; +type NodeConfigValue = Extract['type']; + +class NodeConfigBuilder { + private nodeConfig: NodeConfig = {}; + + set(key: TKey, value: NodeConfigValue): NodeConfigBuilder { + throw new Error(`not yet implemented`); + } + + build(): NodeConfig { + return this.nodeConfig; + } +} + +export function createNodeConfigBuilder(): NodeConfigBuilder { + return new NodeConfigBuilder(); +} + +const nodeConfig = createNodeConfigBuilder() + // + .set('auth.addr', '127.0.0.1') + .set('auth.api', ['eth', 'net', 'web3', 'arb', 'debug']) + .build(); From 96dcf9df4c3eb06f15dfa278e810fe794964adf7 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Fri, 23 Feb 2024 18:07:59 +0100 Subject: [PATCH 02/24] add defaults --- src/nodeConfigBuilder.ts | 60 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 57 insertions(+), 3 deletions(-) diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index 653898ed..1ce86d56 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -16,7 +16,11 @@ type NodeConfigKey = NodeConfigParams['key']; type NodeConfigValue = Extract['type']; class NodeConfigBuilder { - private nodeConfig: NodeConfig = {}; + private nodeConfig: NodeConfig; + + constructor(initialNodeConfig?: NodeConfig) { + this.nodeConfig = initialNodeConfig ?? {}; + } set(key: TKey, value: NodeConfigValue): NodeConfigBuilder { throw new Error(`not yet implemented`); @@ -27,8 +31,18 @@ class NodeConfigBuilder { } } -export function createNodeConfigBuilder(): NodeConfigBuilder { - return new NodeConfigBuilder(); +type CreateNodeConfigBuilderParams = { + withoutDefaults: boolean; +}; + +export function createNodeConfigBuilder(params?: CreateNodeConfigBuilderParams): NodeConfigBuilder { + const withoutDefaults = params?.withoutDefaults ?? false; + + if (withoutDefaults) { + return new NodeConfigBuilder(); + } + + return new NodeConfigBuilder(nodeConfigDefaults); } const nodeConfig = createNodeConfigBuilder() @@ -36,3 +50,43 @@ const nodeConfig = createNodeConfigBuilder() .set('auth.addr', '127.0.0.1') .set('auth.api', ['eth', 'net', 'web3', 'arb', 'debug']) .build(); + +const nodeConfigDefaults: NodeConfig = { + http: { + addr: '0.0.0.0', + port: 8449, + vhosts: ['*'], + corsdomain: ['*'], + api: ['eth', 'net', 'web3', 'arb', 'debug'], + }, + node: { + 'sequencer': true, + 'delayed-sequencer': { + 'enable': true, + 'use-merge-finality': false, + 'finalize-distance': 1, + }, + 'batch-poster': { + 'max-size': 90000, + 'enable': true, + }, + 'staker': { + enable: true, + strategy: 'MakeNodes', + }, + 'dangerous': { + 'no-sequencer-coordinator': true, + }, + }, + execution: { + 'forwarding-target': '', + 'sequencer': { + 'enable': true, + 'max-tx-data-size': 85000, + 'max-block-speed': '250ms', + }, + 'caching': { + archive: true, + }, + }, +}; From aa5533ecf845b249cd58dd8561ed01eeb734147c Mon Sep 17 00:00:00 2001 From: spsjvc Date: Fri, 23 Feb 2024 18:19:17 +0100 Subject: [PATCH 03/24] progress --- src/nodeConfigBuilder.ts | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index 1ce86d56..e6a53879 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -15,6 +15,19 @@ type NodeConfigParams = type NodeConfigKey = NodeConfigParams['key']; type NodeConfigValue = Extract['type']; +const config = { + auth: { + /** + * cool cool + */ + api: 'auth.api', + /** + * asdf asdf + */ + addr: 'auth.addr', + }, +} as const; + class NodeConfigBuilder { private nodeConfig: NodeConfig; @@ -47,8 +60,8 @@ export function createNodeConfigBuilder(params?: CreateNodeConfigBuilderParams): const nodeConfig = createNodeConfigBuilder() // - .set('auth.addr', '127.0.0.1') - .set('auth.api', ['eth', 'net', 'web3', 'arb', 'debug']) + .set(config.auth.addr, '127.0.0.1') + .set(config.auth.api, ['eth']) .build(); const nodeConfigDefaults: NodeConfig = { From f282032a43ac28f280f77a59d844159cc7a072c7 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Fri, 23 Feb 2024 18:21:19 +0100 Subject: [PATCH 04/24] new file --- src/nodeConfigBuilder.ts | 43 ++------------------------------ src/nodeConfigBuilderDefaults.ts | 41 ++++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+), 41 deletions(-) create mode 100644 src/nodeConfigBuilderDefaults.ts diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index e6a53879..dcf64d5d 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -1,4 +1,5 @@ import { NodeConfig } from './types/NodeConfig.generated'; +import { nodeConfigBuilderDefaults } from './nodeConfigBuilderDefaults'; // todo: generate with ts-morph // todo: is there a way to make jsdoc readable when working with the builder? @@ -55,7 +56,7 @@ export function createNodeConfigBuilder(params?: CreateNodeConfigBuilderParams): return new NodeConfigBuilder(); } - return new NodeConfigBuilder(nodeConfigDefaults); + return new NodeConfigBuilder(nodeConfigBuilderDefaults); } const nodeConfig = createNodeConfigBuilder() @@ -63,43 +64,3 @@ const nodeConfig = createNodeConfigBuilder() .set(config.auth.addr, '127.0.0.1') .set(config.auth.api, ['eth']) .build(); - -const nodeConfigDefaults: NodeConfig = { - http: { - addr: '0.0.0.0', - port: 8449, - vhosts: ['*'], - corsdomain: ['*'], - api: ['eth', 'net', 'web3', 'arb', 'debug'], - }, - node: { - 'sequencer': true, - 'delayed-sequencer': { - 'enable': true, - 'use-merge-finality': false, - 'finalize-distance': 1, - }, - 'batch-poster': { - 'max-size': 90000, - 'enable': true, - }, - 'staker': { - enable: true, - strategy: 'MakeNodes', - }, - 'dangerous': { - 'no-sequencer-coordinator': true, - }, - }, - execution: { - 'forwarding-target': '', - 'sequencer': { - 'enable': true, - 'max-tx-data-size': 85000, - 'max-block-speed': '250ms', - }, - 'caching': { - archive: true, - }, - }, -}; diff --git a/src/nodeConfigBuilderDefaults.ts b/src/nodeConfigBuilderDefaults.ts new file mode 100644 index 00000000..dd69d92c --- /dev/null +++ b/src/nodeConfigBuilderDefaults.ts @@ -0,0 +1,41 @@ +import { NodeConfig } from './types/NodeConfig.generated'; + +export const nodeConfigBuilderDefaults: NodeConfig = { + http: { + addr: '0.0.0.0', + port: 8449, + vhosts: ['*'], + corsdomain: ['*'], + api: ['eth', 'net', 'web3', 'arb', 'debug'], + }, + node: { + 'sequencer': true, + 'delayed-sequencer': { + 'enable': true, + 'use-merge-finality': false, + 'finalize-distance': 1, + }, + 'batch-poster': { + 'max-size': 90000, + 'enable': true, + }, + 'staker': { + enable: true, + strategy: 'MakeNodes', + }, + 'dangerous': { + 'no-sequencer-coordinator': true, + }, + }, + execution: { + 'forwarding-target': '', + 'sequencer': { + 'enable': true, + 'max-tx-data-size': 85000, + 'max-block-speed': '250ms', + }, + 'caching': { + archive: true, + }, + }, +}; From 62f4cd11ca4adae8c0afeb1ae5e824fa9b48135a Mon Sep 17 00:00:00 2001 From: spsjvc Date: Tue, 27 Feb 2024 18:47:51 +0100 Subject: [PATCH 05/24] generate more --- src/nodeConfigBuilder.ts | 30 +- src/scripts/generateNodeConfigType.ts | 28 +- src/types/NodeConfig.generated.ts | 2276 ++++++++++++++++++++++++- 3 files changed, 2316 insertions(+), 18 deletions(-) diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index dcf64d5d..42f8194a 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -1,20 +1,14 @@ -import { NodeConfig } from './types/NodeConfig.generated'; +import { NodeConfig, NodeConfigOption } from './types/NodeConfig.generated'; import { nodeConfigBuilderDefaults } from './nodeConfigBuilderDefaults'; -// todo: generate with ts-morph // todo: is there a way to make jsdoc readable when working with the builder? -type NodeConfigParams = - | { - key: 'auth.addr'; - type: string; - } - | { - key: 'auth.api'; - type: string[]; - }; -type NodeConfigKey = NodeConfigParams['key']; -type NodeConfigValue = Extract['type']; +type NodeConfigOptionName = NodeConfigOption['name']; + +type NodeConfigOptionValue = Extract< + NodeConfigOption, + { name: TName } +>['type']; const config = { auth: { @@ -36,7 +30,10 @@ class NodeConfigBuilder { this.nodeConfig = initialNodeConfig ?? {}; } - set(key: TKey, value: NodeConfigValue): NodeConfigBuilder { + set( + name: TName, + value: NodeConfigOptionValue, + ): NodeConfigBuilder { throw new Error(`not yet implemented`); } @@ -63,4 +60,9 @@ const nodeConfig = createNodeConfigBuilder() // .set(config.auth.addr, '127.0.0.1') .set(config.auth.api, ['eth']) + .set('chain.name', 'asdf') + .set('chain.info-json', 'asdf') + .set('parent-chain.connection.url', '') + .set('node.batch-poster.parent-chain-wallet.private-key', '') + .set('node.staker.parent-chain-wallet.private-key', '') .build(); diff --git a/src/scripts/generateNodeConfigType.ts b/src/scripts/generateNodeConfigType.ts index b39e63ac..771659aa 100644 --- a/src/scripts/generateNodeConfigType.ts +++ b/src/scripts/generateNodeConfigType.ts @@ -2,7 +2,7 @@ import { execSync } from 'child_process'; import { readFileSync, rmSync } from 'fs'; import { Project, WriterFunction, Writers } from 'ts-morph'; -const { objectType } = Writers; +const { objectType, unionType } = Writers; function getNitroNodeImageTag(): string { const defaultNitroNodeTag = 'v2.2.5-a20a1c7'; @@ -188,7 +188,31 @@ function main() { sourceFile.addTypeAlias({ name: 'NodeConfig', type: getTypeRecursively(cliOptionsNestedObject), - docs: ['Nitro node configuration options'], + docs: ['Nitro node configuration object'], + isExported: true, + }); + // append NodeConfigOption type declaration + sourceFile.addTypeAlias({ + name: 'NodeConfigOption', + type: unionType( + // @ts-ignore not sure why ts-morph is acting weird here + ...cliOptions.map((option) => + objectType({ + properties: [ + { + name: 'name', + type: `"${option.name}"`, + docs: option.docs, + }, + { + name: 'type', + type: option.type, + }, + ], + }), + ), + ), + docs: ['Union type for all Nitro node configuration options'], isExported: true, }); diff --git a/src/types/NodeConfig.generated.ts b/src/types/NodeConfig.generated.ts index c8a770c8..bb9a1a3d 100644 --- a/src/types/NodeConfig.generated.ts +++ b/src/types/NodeConfig.generated.ts @@ -3,10 +3,10 @@ // THIS FILE IS AUTOMATICALLY GENERATED AND SHOULD NOT BE EDITED MANUALLY // // IMAGE: offchainlabs/nitro-node:v2.2.5-a20a1c7 -// TIMESTAMP: 2024-02-22T17:33:00.049Z +// TIMESTAMP: 2024-02-27T17:43:04.678Z // // --- -/** Nitro node configuration options */ +/** Nitro node configuration object */ export type NodeConfig = { 'auth'?: { /** AUTH-RPC server listening interface (default "127.0.0.1") */ @@ -1095,3 +1095,2275 @@ export type NodeConfig = { 'rpcprefix'?: string; }; }; +/** Union type for all Nitro node configuration options */ +export type NodeConfigOption = + | { + /** AUTH-RPC server listening interface (default "127.0.0.1") */ + name: 'auth.addr'; + type: string; + } + | { + /** APIs offered over the AUTH-RPC interface (default [validation]) */ + name: 'auth.api'; + type: string[]; + } + | { + /** Path to file holding JWT secret (32B hex) */ + name: 'auth.jwtsecret'; + type: string; + } + | { + /** Origins from which to accept AUTH requests (default [localhost]) */ + name: 'auth.origins'; + type: string[]; + } + | { + /** AUTH-RPC server listening port (default 8549) */ + name: 'auth.port'; + type: number; + } + | { + /** minimum number of blocks to execute per thread. When mode is random this acts as the size of random block range sample (default 10000) */ + name: 'blocks-reexecutor.blocks-per-thread'; + type: number; + } + | { + /** enables re-execution of a range of blocks against historic state */ + name: 'blocks-reexecutor.enable'; + type: boolean; + } + | { + /** last block number of the block range for re-execution */ + name: 'blocks-reexecutor.end-block'; + type: number; + } + | { + /** mode to run the blocks-reexecutor on. Valid modes full and random. full - execute all the blocks in the given range. random - execute a random sample range of blocks with in a given range (default "random") */ + name: 'blocks-reexecutor.mode'; + type: string; + } + | { + /** number of threads to parallelize blocks re-execution (default 12) */ + name: 'blocks-reexecutor.room'; + type: number; + } + | { + /** first block number of the block range for re-execution */ + name: 'blocks-reexecutor.start-block'; + type: number; + } + | { + /** account to use (default is first account in keystore) */ + name: 'chain.dev-wallet.account'; + type: string; + } + | { + /** if true, creates new key then exits */ + name: 'chain.dev-wallet.only-create-key'; + type: boolean; + } + | { + /** wallet passphrase (default "PASSWORD_NOT_SET") */ + name: 'chain.dev-wallet.password'; + type: string; + } + | { + /** pathname for wallet */ + name: 'chain.dev-wallet.pathname'; + type: string; + } + | { + /** private key for wallet */ + name: 'chain.dev-wallet.private-key'; + type: string; + } + | { + /** L2 chain ID (determines Arbitrum network) */ + name: 'chain.id'; + type: number; + } + | { + /** L2 chain info json files */ + name: 'chain.info-files'; + type: string[]; + } + | { + /** path to save temp downloaded file (default "/tmp/") */ + name: 'chain.info-ipfs-download-path'; + type: string; + } + | { + /** url to download chain info file */ + name: 'chain.info-ipfs-url'; + type: string; + } + | { + /** L2 chain info in json string format */ + name: 'chain.info-json'; + type: string; + } + | { + /** L2 chain name (determines Arbitrum network) */ + name: 'chain.name'; + type: string; + } + | { + /** print out currently active configuration file */ + name: 'conf.dump'; + type: boolean; + } + | { + /** environment variables with given prefix will be loaded as configuration values */ + name: 'conf.env-prefix'; + type: string; + } + | { + /** name of configuration file */ + name: 'conf.file'; + type: string[]; + } + | { + /** how often to reload configuration (0=disable periodic reloading) */ + name: 'conf.reload-interval'; + type: string; + } + | { + /** S3 access key */ + name: 'conf.s3.access-key'; + type: string; + } + | { + /** S3 bucket */ + name: 'conf.s3.bucket'; + type: string; + } + | { + /** S3 object key */ + name: 'conf.s3.object-key'; + type: string; + } + | { + /** S3 region */ + name: 'conf.s3.region'; + type: string; + } + | { + /** S3 secret key */ + name: 'conf.s3.secret-key'; + type: string; + } + | { + /** configuration as JSON string */ + name: 'conf.string'; + type: string; + } + | { + /** retain past block state */ + name: 'execution.caching.archive'; + type: boolean; + } + | { + /** minimum age of recent blocks to keep in memory (default 30m0s) */ + name: 'execution.caching.block-age'; + type: string; + } + | { + /** minimum number of recent blocks to keep in memory (default 128) */ + name: 'execution.caching.block-count'; + type: number; + } + | { + /** amount of memory in megabytes to cache database contents with (default 2048) */ + name: 'execution.caching.database-cache'; + type: number; + } + | { + /** maximum amount of gas in blocks to skip saving state to Persistent storage (archive node only) -- warning: this option seems to cause issues */ + name: 'execution.caching.max-amount-of-gas-to-skip-state-saving'; + type: number; + } + | { + /** maximum number of blocks to skip state saving to persistent storage (archive node only) -- warning: this option seems to cause issues */ + name: 'execution.caching.max-number-of-blocks-to-skip-state-saving'; + type: number; + } + | { + /** amount of memory in megabytes to cache state snapshots with (default 400) */ + name: 'execution.caching.snapshot-cache'; + type: number; + } + | { + /** maximum gas rolled back to recover snapshot (default 300000000000) */ + name: 'execution.caching.snapshot-restore-gas-limit'; + type: number; + } + | { + /** amount of memory in megabytes to cache unchanged state trie nodes with (default 600) */ + name: 'execution.caching.trie-clean-cache'; + type: number; + } + | { + /** amount of memory in megabytes to cache state diffs against disk with (larger cache lowers database growth) (default 1024) */ + name: 'execution.caching.trie-dirty-cache'; + type: number; + } + | { + /** maximum block processing time before trie is written to hard-disk (default 1h0m0s) */ + name: 'execution.caching.trie-time-limit'; + type: string; + } + | { + /** DANGEROUS! forces a reorg to an old block height. To be used for testing only. -1 to disable (default -1) */ + name: 'execution.dangerous.reorg-to-block'; + type: number; + } + | { + /** enable prefetching of blocks (default true) */ + name: 'execution.enable-prefetch-block'; + type: boolean; + } + | { + /** total time to wait before cancelling connection (default 30s) */ + name: 'execution.forwarder.connection-timeout'; + type: string; + } + | { + /** time until idle connections are closed (default 15s) */ + name: 'execution.forwarder.idle-connection-timeout'; + type: string; + } + | { + /** maximum number of idle connections to keep open (default 1) */ + name: 'execution.forwarder.max-idle-connections'; + type: number; + } + | { + /** the Redis URL to recomend target via */ + name: 'execution.forwarder.redis-url'; + type: string; + } + | { + /** minimal time between update retries (default 100ms) */ + name: 'execution.forwarder.retry-interval'; + type: string; + } + | { + /** forwarding target update interval (default 1s) */ + name: 'execution.forwarder.update-interval'; + type: string; + } + | { + /** transaction forwarding target URL, or "null" to disable forwarding (iff not sequencer) */ + name: 'execution.forwarding-target'; + type: string; + } + | { + /** Dangerous! only meant to be used by system tests */ + name: 'execution.parent-chain-reader.dangerous.wait-for-tx-approval-safe-poll'; + type: string; + } + | { + /** enable reader connection (default true) */ + name: 'execution.parent-chain-reader.enable'; + type: boolean; + } + | { + /** warns if the latest l1 block is at least this old (default 5m0s) */ + name: 'execution.parent-chain-reader.old-header-timeout'; + type: string; + } + | { + /** interval when polling endpoint (default 15s) */ + name: 'execution.parent-chain-reader.poll-interval'; + type: string; + } + | { + /** do not attempt to subscribe to header events */ + name: 'execution.parent-chain-reader.poll-only'; + type: boolean; + } + | { + /** interval for subscribe error (default 5m0s) */ + name: 'execution.parent-chain-reader.subscribe-err-interval'; + type: string; + } + | { + /** timeout when waiting for a transaction (default 5m0s) */ + name: 'execution.parent-chain-reader.tx-timeout'; + type: string; + } + | { + /** use l1 data about finalized/safe blocks (default true) */ + name: 'execution.parent-chain-reader.use-finality-data'; + type: boolean; + } + | { + /** like trie-clean-cache for the separate, recording database (used for validation) (default 16) */ + name: 'execution.recording-database.trie-clean-cache'; + type: number; + } + | { + /** like trie-dirty-cache for the separate, recording database (used for validation) (default 1024) */ + name: 'execution.recording-database.trie-dirty-cache'; + type: number; + } + | { + /** list of whitelisted rpc methods */ + name: 'execution.rpc.allow-method'; + type: string[]; + } + | { + /** bounds the number of blocks arbdebug calls may return (default 256) */ + name: 'execution.rpc.arbdebug.block-range-bound'; + type: number; + } + | { + /** bounds the length of timeout queues arbdebug calls may return (default 512) */ + name: 'execution.rpc.arbdebug.timeout-queue-bound'; + type: number; + } + | { + /** number of blocks a single bloom bit section vector holds (default 16384) */ + name: 'execution.rpc.bloom-bits-blocks'; + type: number; + } + | { + /** number of confirmation blocks before a bloom section is considered final (default 256) */ + name: 'execution.rpc.bloom-confirms'; + type: number; + } + | { + /** url to redirect classic requests, use "error:[CODE:]MESSAGE" to return specified error instead of redirecting */ + name: 'execution.rpc.classic-redirect'; + type: string; + } + | { + /** timeout for forwarded classic requests, where 0 = no timeout */ + name: 'execution.rpc.classic-redirect-timeout'; + type: string; + } + | { + /** timeout used for eth_call (0=infinite) (default 5s) */ + name: 'execution.rpc.evm-timeout'; + type: string; + } + | { + /** max number of blocks a fee history request may cover (default 1024) */ + name: 'execution.rpc.feehistory-max-block-count'; + type: number; + } + | { + /** log filter system maximum number of cached blocks (default 32) */ + name: 'execution.rpc.filter-log-cache-size'; + type: number; + } + | { + /** log filter system maximum time filters stay active (default 5m0s) */ + name: 'execution.rpc.filter-timeout'; + type: string; + } + | { + /** cap on computation gas that can be used in eth_call/estimateGas (0=infinite) (default 50000000) */ + name: 'execution.rpc.gas-cap'; + type: number; + } + | { + /** maximum depth for recreating state, measured in l2 gas (0=don't recreate state, -1=infinite, -2=use default value for archive or non-archive node (whichever is configured)) (default -2) */ + name: 'execution.rpc.max-recreate-state-depth'; + type: number; + } + | { + /** allow transactions that aren't EIP-155 replay protected to be submitted over the RPC (default true) */ + name: 'execution.rpc.tx-allow-unprotected'; + type: boolean; + } + | { + /** cap on transaction fee (in ether) that can be sent via the RPC APIs (0 = no cap) (default 1) */ + name: 'execution.rpc.tx-fee-cap'; + type: number; + } + | { + /** secondary transaction forwarding target URL */ + name: 'execution.secondary-forwarding-target'; + type: string[]; + } + | { + /** act and post to l1 as sequencer */ + name: 'execution.sequencer.enable'; + type: boolean; + } + | { + /** total time to wait before cancelling connection (default 30s) */ + name: 'execution.sequencer.forwarder.connection-timeout'; + type: string; + } + | { + /** time until idle connections are closed (default 1m0s) */ + name: 'execution.sequencer.forwarder.idle-connection-timeout'; + type: string; + } + | { + /** maximum number of idle connections to keep open (default 100) */ + name: 'execution.sequencer.forwarder.max-idle-connections'; + type: number; + } + | { + /** the Redis URL to recomend target via */ + name: 'execution.sequencer.forwarder.redis-url'; + type: string; + } + | { + /** minimal time between update retries (default 100ms) */ + name: 'execution.sequencer.forwarder.retry-interval'; + type: string; + } + | { + /** forwarding target update interval (default 1s) */ + name: 'execution.sequencer.forwarder.update-interval'; + type: string; + } + | { + /** maximum acceptable time difference between the local time and the latest L1 block's timestamp (default 1h0m0s) */ + name: 'execution.sequencer.max-acceptable-timestamp-delta'; + type: string; + } + | { + /** minimum delay between blocks (sets a maximum speed of block production) (default 250ms) */ + name: 'execution.sequencer.max-block-speed'; + type: string; + } + | { + /** maximum gas executed in a revert for the sequencer to reject the transaction instead of posting it (anti-DOS) (default 31000) */ + name: 'execution.sequencer.max-revert-gas-reject'; + type: number; + } + | { + /** maximum transaction size the sequencer will accept (default 95000) */ + name: 'execution.sequencer.max-tx-data-size'; + type: number; + } + | { + /** size of the tx sender nonce cache (default 1024) */ + name: 'execution.sequencer.nonce-cache-size'; + type: number; + } + | { + /** maximum amount of time to wait for a predecessor before rejecting a tx with nonce too high (default 1s) */ + name: 'execution.sequencer.nonce-failure-cache-expiry'; + type: string; + } + | { + /** number of transactions with too high of a nonce to keep in memory while waiting for their predecessor (default 1024) */ + name: 'execution.sequencer.nonce-failure-cache-size'; + type: number; + } + | { + /** size of the pending tx queue (default 1024) */ + name: 'execution.sequencer.queue-size'; + type: number; + } + | { + /** maximum amount of time transaction can wait in queue (default 12s) */ + name: 'execution.sequencer.queue-timeout'; + type: string; + } + | { + /** comma separated whitelist of authorized senders (if empty, everyone is allowed) */ + name: 'execution.sequencer.sender-whitelist'; + type: string; + } + | { + /** retain the ability to lookup transactions by hash for the past N blocks (0 = all blocks) (default 126230400) */ + name: 'execution.tx-lookup-limit'; + type: number; + } + | { + /** how long ago should the storage conditions from eth_SendRawTransactionConditional be true, 0 = don't check old state (default 2) */ + name: 'execution.tx-pre-checker.required-state-age'; + type: number; + } + | { + /** maximum number of blocks to look back while looking for the seconds old state, 0 = don't limit the search (default 4) */ + name: 'execution.tx-pre-checker.required-state-max-blocks'; + type: number; + } + | { + /** how strict to be when checking txs before forwarding them. 0 = accept anything, 10 = should never reject anything that'd succeed, 20 = likely won't reject anything that'd succeed, 30 = full validation which may reject txs that would succeed */ + name: 'execution.tx-pre-checker.strictness'; + type: number; + } + | { + /** size of intermediate log records buffer (default 512) */ + name: 'file-logging.buf-size'; + type: number; + } + | { + /** enable compression of old log files (default true) */ + name: 'file-logging.compress'; + type: boolean; + } + | { + /** enable logging to file (default true) */ + name: 'file-logging.enable'; + type: boolean; + } + | { + /** path to log file (default "nitro.log") */ + name: 'file-logging.file'; + type: string; + } + | { + /** if true: local time will be used in old log filename timestamps */ + name: 'file-logging.local-time'; + type: boolean; + } + | { + /** maximum number of days to retain old log files based on the timestamp encoded in their filename (0 = no limit) */ + name: 'file-logging.max-age'; + type: number; + } + | { + /** maximum number of old log files to retain (0 = no limit) (default 20) */ + name: 'file-logging.max-backups'; + type: number; + } + | { + /** log file size in Mb that will trigger log file rotation (0 = trigger disabled) (default 5) */ + name: 'file-logging.max-size'; + type: number; + } + | { + /** Comma separated list of domains from which to accept cross origin requests (browser enforced) */ + name: 'graphql.corsdomain'; + type: string[]; + } + | { + /** Enable graphql endpoint on the rpc endpoint */ + name: 'graphql.enable'; + type: boolean; + } + | { + /** Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard (default [localhost]) */ + name: 'graphql.vhosts'; + type: string[]; + } + | { + /** HTTP-RPC server listening interface */ + name: 'http.addr'; + type: string; + } + | { + /** APIs offered over the HTTP-RPC interface (default [net,web3,eth,arb]) */ + name: 'http.api'; + type: string[]; + } + | { + /** Comma separated list of domains from which to accept cross origin requests (browser enforced) */ + name: 'http.corsdomain'; + type: string[]; + } + | { + /** HTTP-RPC server listening port (default 8547) */ + name: 'http.port'; + type: number; + } + | { + /** HTTP path path prefix on which JSON-RPC is served. Use '/' to serve on all paths */ + name: 'http.rpcprefix'; + type: string; + } + | { + /** the maximum amount of time to wait for the next request when keep-alives are enabled (http.Server.IdleTimeout) (default 2m0s) */ + name: 'http.server-timeouts.idle-timeout'; + type: string; + } + | { + /** the amount of time allowed to read the request headers (http.Server.ReadHeaderTimeout) (default 30s) */ + name: 'http.server-timeouts.read-header-timeout'; + type: string; + } + | { + /** the maximum duration for reading the entire request (http.Server.ReadTimeout) (default 30s) */ + name: 'http.server-timeouts.read-timeout'; + type: string; + } + | { + /** the maximum duration before timing out writes of the response (http.Server.WriteTimeout) (default 30s) */ + name: 'http.server-timeouts.write-timeout'; + type: string; + } + | { + /** Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard (default [localhost]) */ + name: 'http.vhosts'; + type: string[]; + } + | { + /** during init - sync database every X accounts. Lower value for low-memory systems. 0 disables. (default 100000) */ + name: 'init.accounts-per-sync'; + type: number; + } + | { + /** init with dev data (1 account with balance) instead of file import */ + name: 'init.dev-init'; + type: boolean; + } + | { + /** Address of dev-account. Leave empty to use the dev-wallet. */ + name: 'init.dev-init-address'; + type: string; + } + | { + /** Number of preinit blocks. Must exist in ancient database. */ + name: 'init.dev-init-blocknum'; + type: number; + } + | { + /** path to save temp downloaded file (default "/tmp/") */ + name: 'init.download-path'; + type: string; + } + | { + /** how long to wait between polling attempts (default 1m0s) */ + name: 'init.download-poll'; + type: string; + } + | { + /** init with empty state */ + name: 'init.empty'; + type: boolean; + } + | { + /** if true: in case database exists init code will be reexecuted and genesis block compared to database */ + name: 'init.force'; + type: boolean; + } + | { + /** path for json data to import */ + name: 'init.import-file'; + type: string; + } + | { + /** pruning for a given use: "full" for full nodes serving RPC requests, or "validator" for validators */ + name: 'init.prune'; + type: string; + } + | { + /** the amount of memory in megabytes to use for the pruning bloom filter (higher values prune better) (default 2048) */ + name: 'init.prune-bloom-size'; + type: number; + } + | { + /** block number to start recreating missing states from (0 = disabled) */ + name: 'init.recreate-missing-state-from'; + type: number; + } + | { + /** forces a reset to an old message height. Also set max-reorg-resequence-depth=0 to force re-reading messages (default -1) */ + name: 'init.reset-to-message'; + type: number; + } + | { + /** quit after init is done */ + name: 'init.then-quit'; + type: boolean; + } + | { + /** url to download initializtion data - will poll if download fails */ + name: 'init.url'; + type: string; + } + | { + /** Requested location to place the IPC endpoint. An empty path disables IPC. */ + name: 'ipc.path'; + type: string; + } + | { + /** log level (default 3) */ + name: 'log-level'; + type: number; + } + | { + /** log type (plaintext or json) (default "plaintext") */ + name: 'log-type'; + type: string; + } + | { + /** enable metrics */ + name: 'metrics'; + type: boolean; + } + | { + /** metrics server address (default "127.0.0.1") */ + name: 'metrics-server.addr'; + type: string; + } + | { + /** metrics server port (default 6070) */ + name: 'metrics-server.port'; + type: number; + } + | { + /** metrics server update interval (default 3s) */ + name: 'metrics-server.update-interval'; + type: string; + } + | { + /** batch compression level (default 11) */ + name: 'node.batch-poster.compression-level'; + type: number; + } + | { + /** In AnyTrust mode, the period which DASes are requested to retain the stored batches. (default 360h0m0s) */ + name: 'node.batch-poster.das-retention-period'; + type: string; + } + | { + /** if true, don't put transactions in the mempool that spend a total greater than the batch poster's balance (default true) */ + name: 'node.batch-poster.data-poster.allocate-mempool-balance'; + type: boolean; + } + | { + /** clear database storage */ + name: 'node.batch-poster.data-poster.dangerous.clear-dbstorage'; + type: boolean; + } + | { + /** unit to measure the time elapsed since creation of transaction used for maximum fee cap calculation (default 10m0s) */ + name: 'node.batch-poster.data-poster.elapsed-time-base'; + type: string; + } + | { + /** weight given to the units of time elapsed used for maximum fee cap calculation (default 10) */ + name: 'node.batch-poster.data-poster.elapsed-time-importance'; + type: number; + } + | { + /** external signer address */ + name: 'node.batch-poster.data-poster.external-signer.address'; + type: string; + } + | { + /** rpc client cert */ + name: 'node.batch-poster.data-poster.external-signer.client-cert'; + type: string; + } + | { + /** rpc client private key */ + name: 'node.batch-poster.data-poster.external-signer.client-private-key'; + type: string; + } + | { + /** external signer method (default "eth_signTransaction") */ + name: 'node.batch-poster.data-poster.external-signer.method'; + type: string; + } + | { + /** external signer root CA */ + name: 'node.batch-poster.data-poster.external-signer.root-ca'; + type: string; + } + | { + /** external signer url */ + name: 'node.batch-poster.data-poster.external-signer.url'; + type: string; + } + | { + /** encodes items in a legacy way (as it was before dropping generics) */ + name: 'node.batch-poster.data-poster.legacy-storage-encoding'; + type: boolean; + } + | { + /** mathematical formula to calculate maximum fee cap gwei the result of which would be float64. This expression is expected to be evaluated please refer https://github.com/Knetic/govaluate/blob/master/MANUAL.md to find all available mathematical operators. Currently available variables to construct the formula are BacklogOfBatches, UrgencyGWei, ElapsedTime, ElapsedTimeBase, ElapsedTimeImportance, and TargetPriceGWei (default "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei") */ + name: 'node.batch-poster.data-poster.max-fee-cap-formula'; + type: string; + } + | { + /** the maximum number of transactions to have queued in the mempool at once (0 = unlimited) (default 20) */ + name: 'node.batch-poster.data-poster.max-mempool-transactions'; + type: number; + } + | { + /** the maximum number of unconfirmed transactions to track at once (0 = unlimited) */ + name: 'node.batch-poster.data-poster.max-queued-transactions'; + type: number; + } + | { + /** the maximum tip cap to post transactions at (default 5) */ + name: 'node.batch-poster.data-poster.max-tip-cap-gwei'; + type: number; + } + | { + /** the minimum fee cap to post transactions at */ + name: 'node.batch-poster.data-poster.min-fee-cap-gwei'; + type: number; + } + | { + /** the minimum tip cap to post transactions at (default 0.05) */ + name: 'node.batch-poster.data-poster.min-tip-cap-gwei'; + type: number; + } + | { + /** the maximum probable reorg depth, used to determine when a transaction will no longer likely need replaced-by-fee (default 1) */ + name: 'node.batch-poster.data-poster.nonce-rbf-soft-confs'; + type: number; + } + | { + /** disable message signature verification */ + name: 'node.batch-poster.data-poster.redis-signer.dangerous.disable-signature-verification'; + type: boolean; + } + | { + /** a fallback key used for message verification */ + name: 'node.batch-poster.data-poster.redis-signer.fallback-verification-key'; + type: string; + } + | { + /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ + name: 'node.batch-poster.data-poster.redis-signer.signing-key'; + type: string; + } + | { + /** comma-separated list of durations since first posting to attempt a replace-by-fee (default "5m,10m,20m,30m,1h,2h,4h,6h,8h,12h,16h,18h,20h,22h") */ + name: 'node.batch-poster.data-poster.replacement-times'; + type: string; + } + | { + /** the target price to use for maximum fee cap calculation (default 60) */ + name: 'node.batch-poster.data-poster.target-price-gwei'; + type: number; + } + | { + /** the urgency to use for maximum fee cap calculation (default 2) */ + name: 'node.batch-poster.data-poster.urgency-gwei'; + type: number; + } + | { + /** uses database storage when enabled (default true) */ + name: 'node.batch-poster.data-poster.use-db-storage'; + type: boolean; + } + | { + /** uses noop storage, it doesn't store anything */ + name: 'node.batch-poster.data-poster.use-noop-storage'; + type: boolean; + } + | { + /** only treat a transaction as confirmed after L1 finality has been achieved (recommended) (default true) */ + name: 'node.batch-poster.data-poster.wait-for-l1-finality'; + type: boolean; + } + | { + /** If unable to batch to DAS, disable fallback storing data on chain */ + name: 'node.batch-poster.disable-das-fallback-store-data-on-chain'; + type: boolean; + } + | { + /** enable posting batches to l1 */ + name: 'node.batch-poster.enable'; + type: boolean; + } + | { + /** how long to delay after error posting batch (default 10s) */ + name: 'node.batch-poster.error-delay'; + type: string; + } + | { + /** use this much more gas than estimation says is necessary to post batches (default 50000) */ + name: 'node.batch-poster.extra-batch-gas'; + type: number; + } + | { + /** The gas refunder contract address (optional) */ + name: 'node.batch-poster.gas-refunder-address'; + type: string; + } + | { + /** if the parent chain supports 4844 blobs and ignore-blob-price is true, post 4844 blobs even if it's not price efficient */ + name: 'node.batch-poster.ignore-blob-price'; + type: boolean; + } + | { + /** only post messages to batches when they're within the max future block/timestamp as of this L1 block tag ("safe", "finalized", "latest", or "ignore" to ignore this check) */ + name: 'node.batch-poster.l1-block-bound'; + type: string; + } + | { + /** post batches even if not within the layer 1 future bounds if we're within this margin of the max delay (default 1h0m0s) */ + name: 'node.batch-poster.l1-block-bound-bypass'; + type: string; + } + | { + /** maximum 4844 blob enabled batch size (default 779288) */ + name: 'node.batch-poster.max-4844-batch-size'; + type: number; + } + | { + /** maximum batch posting delay (default 1h0m0s) */ + name: 'node.batch-poster.max-delay'; + type: string; + } + | { + /** maximum batch size (default 100000) */ + name: 'node.batch-poster.max-size'; + type: number; + } + | { + /** account to use (default is first account in keystore) */ + name: 'node.batch-poster.parent-chain-wallet.account'; + type: string; + } + | { + /** if true, creates new key then exits */ + name: 'node.batch-poster.parent-chain-wallet.only-create-key'; + type: boolean; + } + | { + /** wallet passphrase (default "PASSWORD_NOT_SET") */ + name: 'node.batch-poster.parent-chain-wallet.password'; + type: string; + } + | { + /** pathname for wallet (default "batch-poster-wallet") */ + name: 'node.batch-poster.parent-chain-wallet.pathname'; + type: string; + } + | { + /** private key for wallet */ + name: 'node.batch-poster.parent-chain-wallet.private-key'; + type: string; + } + | { + /** how long to wait after no batches are ready to be posted before checking again (default 10s) */ + name: 'node.batch-poster.poll-interval'; + type: string; + } + | { + /** if the parent chain supports 4844 blobs and they're well priced, post EIP-4844 blobs */ + name: 'node.batch-poster.post-4844-blobs'; + type: boolean; + } + | { + /** should node always try grabing lock in background */ + name: 'node.batch-poster.redis-lock.background-lock'; + type: boolean; + } + | { + /** if false, always treat this as locked and don't write the lock to redis (default true) */ + name: 'node.batch-poster.redis-lock.enable'; + type: boolean; + } + | { + /** key for lock */ + name: 'node.batch-poster.redis-lock.key'; + type: string; + } + | { + /** how long lock is held (default 1m0s) */ + name: 'node.batch-poster.redis-lock.lockout-duration'; + type: string; + } + | { + /** this node's id prefix when acquiring the lock (optional) */ + name: 'node.batch-poster.redis-lock.my-id'; + type: string; + } + | { + /** how long between consecutive calls to redis (default 10s) */ + name: 'node.batch-poster.redis-lock.refresh-duration'; + type: string; + } + | { + /** if non-empty, the Redis URL to store queued transactions in */ + name: 'node.batch-poster.redis-url'; + type: string; + } + | { + /** post batches with access lists to reduce gas usage (disabled for L3s) (default true) */ + name: 'node.batch-poster.use-access-lists'; + type: boolean; + } + | { + /** wait for the max batch delay, even if the batch is full */ + name: 'node.batch-poster.wait-for-max-delay'; + type: boolean; + } + | { + /** Beacon Chain url to use for fetching blobs */ + name: 'node.blob-client.beacon-chain-url'; + type: string; + } + | { + /** Full path of the directory to save fetched blobs */ + name: 'node.blob-client.blob-directory'; + type: string; + } + | { + /** current wasm module root ('current' read from chain, 'latest' from machines/latest dir, or provide hash) (default "current") */ + name: 'node.block-validator.current-module-root'; + type: string; + } + | { + /** resets block-by-block validation, starting again at genesis */ + name: 'node.block-validator.dangerous.reset-block-validation'; + type: boolean; + } + | { + /** enable block-by-block validation */ + name: 'node.block-validator.enable'; + type: boolean; + } + | { + /** failing a validation is treated as a fatal error (default true) */ + name: 'node.block-validator.failure-is-fatal'; + type: boolean; + } + | { + /** prepare entries for up to that many blocks ahead of validation (small footprint) (default 1024) */ + name: 'node.block-validator.forward-blocks'; + type: number; + } + | { + /** minimum free-memory limit after reaching which the blockvalidator pauses validation. Enabled by default as 1GB, to disable provide empty string (default "default") */ + name: 'node.block-validator.memory-free-limit'; + type: string; + } + | { + /** pending upgrade wasm module root to additionally validate (hash, 'latest' or empty) (default "latest") */ + name: 'node.block-validator.pending-upgrade-module-root'; + type: string; + } + | { + /** record that many blocks ahead of validation (larger footprint) (default 24) */ + name: 'node.block-validator.prerecorded-blocks'; + type: number; + } + | { + /** poll time to check validations (default 1s) */ + name: 'node.block-validator.validation-poll'; + type: string; + } + | { + /** array of validation rpc configs given as a json string. time duration should be supplied in number indicating nanoseconds (default "default") */ + name: 'node.block-validator.validation-server-configs-list'; + type: string; + } + | { + /** limit size of arguments in log entries (default 2048) */ + name: 'node.block-validator.validation-server.arg-log-limit'; + type: number; + } + | { + /** how long to wait for initial connection */ + name: 'node.block-validator.validation-server.connection-wait'; + type: string; + } + | { + /** path to file with jwtsecret for validation - ignored if url is self or self-auth */ + name: 'node.block-validator.validation-server.jwtsecret'; + type: string; + } + | { + /** number of retries in case of failure(0 mean one attempt) (default 3) */ + name: 'node.block-validator.validation-server.retries'; + type: number; + } + | { + /** delay between retries */ + name: 'node.block-validator.validation-server.retry-delay'; + type: string; + } + | { + /** Errors matching this regular expression are automatically retried (default "websocket: close.*|dial tcp .*|.*i/o timeout|.*connection reset by peer|.*connection refused") */ + name: 'node.block-validator.validation-server.retry-errors'; + type: string; + } + | { + /** per-response timeout (0-disabled) */ + name: 'node.block-validator.validation-server.timeout'; + type: string; + } + | { + /** url of server, use self for loopback websocket, self-auth for loopback with authentication (default "self-auth") */ + name: 'node.block-validator.validation-server.url'; + type: string; + } + | { + /** DANGEROUS! disables listening to L1. To be used in test nodes only */ + name: 'node.dangerous.no-l1-listener'; + type: boolean; + } + | { + /** DANGEROUS! allows sequencing without sequencer-coordinator */ + name: 'node.dangerous.no-sequencer-coordinator'; + type: boolean; + } + | { + /** enable Anytrust Data Availability mode */ + name: 'node.data-availability.enable'; + type: boolean; + } + | { + /** enable storage/retrieval of sequencer batch data from IPFS */ + name: 'node.data-availability.ipfs-storage.enable'; + type: boolean; + } + | { + /** list of IPFS peers to connect to, eg /ip4/1.2.3.4/tcp/12345/p2p/abc...xyz */ + name: 'node.data-availability.ipfs-storage.peers'; + type: string[]; + } + | { + /** pin sequencer batch data in IPFS (default true) */ + name: 'node.data-availability.ipfs-storage.pin-after-get'; + type: boolean; + } + | { + /** percent of sequencer batch data to pin, as a floating point number in the range 0.0 to 100.0 (default 100) */ + name: 'node.data-availability.ipfs-storage.pin-percentage'; + type: number; + } + | { + /** comma separated list of IPFS profiles to use, see https://docs.ipfs.tech/how-to/default-profile */ + name: 'node.data-availability.ipfs-storage.profiles'; + type: string; + } + | { + /** timeout for IPFS reads, since by default it will wait forever. Treat timeout as not found (default 1m0s) */ + name: 'node.data-availability.ipfs-storage.read-timeout'; + type: string; + } + | { + /** directory to use to store the local IPFS repo */ + name: 'node.data-availability.ipfs-storage.repo-dir'; + type: string; + } + | { + /** whether the Data Availability Service should fail immediately on errors (not recommended) */ + name: 'node.data-availability.panic-on-error'; + type: boolean; + } + | { + /** parent chain RPC connection attempts (spaced out at least 1 second per attempt, 0 to retry infinitely), only used in standalone daserver; when running as part of a node that node's parent chain configuration is used (default 15) */ + name: 'node.data-availability.parent-chain-connection-attempts'; + type: number; + } + | { + /** URL for parent chain node, only used in standalone daserver; when running as part of a node that node's L1 configuration is used */ + name: 'node.data-availability.parent-chain-node-url'; + type: string; + } + | { + /** Data Availability Service timeout duration for Store requests (default 5s) */ + name: 'node.data-availability.request-timeout'; + type: string; + } + | { + /** enable retrieval of sequencer batch data from a list of remote REST endpoints; if other DAS storage types are enabled, this mode is used as a fallback */ + name: 'node.data-availability.rest-aggregator.enable'; + type: boolean; + } + | { + /** number of stats entries (latency and success rate) to keep for each REST endpoint; controls whether strategy is faster or slower to respond to changing conditions (default 20) */ + name: 'node.data-availability.rest-aggregator.max-per-endpoint-stats'; + type: number; + } + | { + /** a URL to a list of URLs of REST das endpoints that is checked at startup; additive with the url option */ + name: 'node.data-availability.rest-aggregator.online-url-list'; + type: string; + } + | { + /** time interval to periodically fetch url list from online-url-list (default 1h0m0s) */ + name: 'node.data-availability.rest-aggregator.online-url-list-fetch-interval'; + type: string; + } + | { + /** number of consecutive GetByHash calls to the aggregator where each call will cause it to select from REST endpoints in order of best latency and success rate, before switching to explore mode (default 1000) */ + name: 'node.data-availability.rest-aggregator.simple-explore-exploit-strategy.exploit-iterations'; + type: number; + } + | { + /** number of consecutive GetByHash calls to the aggregator where each call will cause it to randomly select from REST endpoints until one returns successfully, before switching to exploit mode (default 20) */ + name: 'node.data-availability.rest-aggregator.simple-explore-exploit-strategy.explore-iterations'; + type: number; + } + | { + /** strategy to use to determine order and parallelism of calling REST endpoint URLs; valid options are 'simple-explore-exploit' (default "simple-explore-exploit") */ + name: 'node.data-availability.rest-aggregator.strategy'; + type: string; + } + | { + /** how frequently to update the strategy with endpoint latency and error rate data (default 10s) */ + name: 'node.data-availability.rest-aggregator.strategy-update-interval'; + type: string; + } + | { + /** check if the data already exists in this DAS's storage. Must be disabled for fast sync with an IPFS backend (default true) */ + name: 'node.data-availability.rest-aggregator.sync-to-storage.check-already-exists'; + type: boolean; + } + | { + /** time to wait if encountered an error before retrying (default 1s) */ + name: 'node.data-availability.rest-aggregator.sync-to-storage.delay-on-error'; + type: string; + } + | { + /** eagerly sync batch data to this DAS's storage from the rest endpoints, using L1 as the index of batch data hashes; otherwise only sync lazily */ + name: 'node.data-availability.rest-aggregator.sync-to-storage.eager'; + type: boolean; + } + | { + /** when eagerly syncing, start indexing forward from this L1 block. Only used if there is no sync state */ + name: 'node.data-availability.rest-aggregator.sync-to-storage.eager-lower-bound-block'; + type: number; + } + | { + /** log only on failures to write when syncing; otherwise treat it as an error (default true) */ + name: 'node.data-availability.rest-aggregator.sync-to-storage.ignore-write-errors'; + type: boolean; + } + | { + /** when eagerly syncing, max l1 blocks to read per poll (default 100) */ + name: 'node.data-availability.rest-aggregator.sync-to-storage.parent-chain-blocks-per-read'; + type: number; + } + | { + /** period to retain synced data (defaults to forever) (default 2562047h47m16.854775807s) */ + name: 'node.data-availability.rest-aggregator.sync-to-storage.retention-period'; + type: string; + } + | { + /** directory to store the sync state in, ie the block number currently synced up to, so that we don't sync from scratch each time */ + name: 'node.data-availability.rest-aggregator.sync-to-storage.state-dir'; + type: string; + } + | { + /** list of URLs including 'http://' or 'https://' prefixes and port numbers to REST DAS endpoints; additive with the online-url-list option */ + name: 'node.data-availability.rest-aggregator.urls'; + type: string[]; + } + | { + /** time to wait until trying the next set of REST endpoints while waiting for a response; the next set of REST endpoints is determined by the strategy selected (default 2s) */ + name: 'node.data-availability.rest-aggregator.wait-before-try-next'; + type: string; + } + | { + /** Number of assumed honest backends (H). If there are N backends, K=N+1-H valid responses are required to consider an Store request to be successful. */ + name: 'node.data-availability.rpc-aggregator.assumed-honest'; + type: number; + } + | { + /** JSON RPC backend configuration */ + name: 'node.data-availability.rpc-aggregator.backends'; + type: string; + } + | { + /** enable storage/retrieval of sequencer batch data from a list of RPC endpoints; this should only be used by the batch poster and not in combination with other DAS storage types */ + name: 'node.data-availability.rpc-aggregator.enable'; + type: boolean; + } + | { + /** parent chain address of SequencerInbox contract */ + name: 'node.data-availability.sequencer-inbox-address'; + type: string; + } + | { + /** enable delayed sequencer */ + name: 'node.delayed-sequencer.enable'; + type: boolean; + } + | { + /** how many blocks in the past L1 block is considered final (ignored when using Merge finality) (default 20) */ + name: 'node.delayed-sequencer.finalize-distance'; + type: number; + } + | { + /** whether to wait for full finality before sequencing delayed messages */ + name: 'node.delayed-sequencer.require-full-finality'; + type: boolean; + } + | { + /** whether to use The Merge's notion of finality before sequencing delayed messages (default true) */ + name: 'node.delayed-sequencer.use-merge-finality'; + type: boolean; + } + | { + /** enable per message deflate compression support (default true) */ + name: 'node.feed.input.enable-compression'; + type: boolean; + } + | { + /** initial duration to wait before reconnect (default 1s) */ + name: 'node.feed.input.reconnect-initial-backoff'; + type: string; + } + | { + /** maximum duration to wait before reconnect (default 1m4s) */ + name: 'node.feed.input.reconnect-maximum-backoff'; + type: string; + } + | { + /** require chain id to be present on connect */ + name: 'node.feed.input.require-chain-id'; + type: boolean; + } + | { + /** require feed version to be present on connect */ + name: 'node.feed.input.require-feed-version'; + type: boolean; + } + | { + /** list of secondary URLs of sequencer feed source. Would be started in the order they appear in the list when primary feeds fails */ + name: 'node.feed.input.secondary-url'; + type: string[]; + } + | { + /** duration to wait before timing out connection to sequencer feed (default 20s) */ + name: 'node.feed.input.timeout'; + type: string; + } + | { + /** list of primary URLs of sequencer feed source */ + name: 'node.feed.input.url'; + type: string[]; + } + | { + /** accept verified message from sequencer (default true) */ + name: 'node.feed.input.verify.accept-sequencer'; + type: boolean; + } + | { + /** a list of allowed addresses */ + name: 'node.feed.input.verify.allowed-addresses'; + type: string[]; + } + | { + /** accept empty as valid signature (default true) */ + name: 'node.feed.input.verify.dangerous.accept-missing'; + type: boolean; + } + | { + /** address to bind the relay feed output to */ + name: 'node.feed.output.addr'; + type: string; + } + | { + /** the maximum number of messages each segment within the backlog can contain (default 240) */ + name: 'node.feed.output.backlog.segment-limit'; + type: number; + } + | { + /** delay the first messages sent to each client by this amount */ + name: 'node.feed.output.client-delay'; + type: string; + } + | { + /** duration to wait before timing out connections to client (default 15s) */ + name: 'node.feed.output.client-timeout'; + type: string; + } + | { + /** enable broadcaster per-client connection limiting */ + name: 'node.feed.output.connection-limits.enable'; + type: boolean; + } + | { + /** limit clients, as identified by IPv4/v6 address, to this many connections to this relay (default 5) */ + name: 'node.feed.output.connection-limits.per-ip-limit'; + type: number; + } + | { + /** limit ipv6 clients, as identified by IPv6 address masked with /48, to this many connections to this relay (default 20) */ + name: 'node.feed.output.connection-limits.per-ipv6-cidr-48-limit'; + type: number; + } + | { + /** limit ipv6 clients, as identified by IPv6 address masked with /64, to this many connections to this relay (default 10) */ + name: 'node.feed.output.connection-limits.per-ipv6-cidr-64-limit'; + type: number; + } + | { + /** time to wait after a relay client disconnects before the disconnect is registered with respect to the limit for this client */ + name: 'node.feed.output.connection-limits.reconnect-cooldown-period'; + type: string; + } + | { + /** don't sign feed messages (default true) */ + name: 'node.feed.output.disable-signing'; + type: boolean; + } + | { + /** enable broadcaster */ + name: 'node.feed.output.enable'; + type: boolean; + } + | { + /** enable per message deflate compression support */ + name: 'node.feed.output.enable-compression'; + type: boolean; + } + | { + /** duration to wait before timing out HTTP to WS upgrade (default 1s) */ + name: 'node.feed.output.handshake-timeout'; + type: string; + } + | { + /** only supply catchup buffer if requested sequence number is reasonable */ + name: 'node.feed.output.limit-catchup'; + type: boolean; + } + | { + /** log every client connect */ + name: 'node.feed.output.log-connect'; + type: boolean; + } + | { + /** log every client disconnect */ + name: 'node.feed.output.log-disconnect'; + type: boolean; + } + | { + /** the maximum size of the catchup buffer (-1 means unlimited) (default -1) */ + name: 'node.feed.output.max-catchup'; + type: number; + } + | { + /** maximum number of messages allowed to accumulate before client is disconnected (default 4096) */ + name: 'node.feed.output.max-send-queue'; + type: number; + } + | { + /** duration for ping interval (default 5s) */ + name: 'node.feed.output.ping'; + type: string; + } + | { + /** port to bind the relay feed output to (default "9642") */ + name: 'node.feed.output.port'; + type: string; + } + | { + /** queue size for HTTP to WS upgrade (default 100) */ + name: 'node.feed.output.queue'; + type: number; + } + | { + /** duration to wait before timing out reading data (i.e. pings) from clients (default 1s) */ + name: 'node.feed.output.read-timeout'; + type: string; + } + | { + /** require clients to use compression */ + name: 'node.feed.output.require-compression'; + type: boolean; + } + | { + /** don't connect if client version not present */ + name: 'node.feed.output.require-version'; + type: boolean; + } + | { + /** sign broadcast messages */ + name: 'node.feed.output.signed'; + type: boolean; + } + | { + /** number of threads to reserve for HTTP to WS upgrade (default 100) */ + name: 'node.feed.output.workers'; + type: number; + } + | { + /** duration to wait before timing out writing data to clients (default 2s) */ + name: 'node.feed.output.write-timeout'; + type: string; + } + | { + /** the maximum time to wait between inbox checks (if not enough new blocks are found) (default 1m0s) */ + name: 'node.inbox-reader.check-delay'; + type: string; + } + | { + /** the default number of blocks to read at once (will vary based on traffic by default) (default 100) */ + name: 'node.inbox-reader.default-blocks-to-read'; + type: number; + } + | { + /** number of latest blocks to ignore to reduce reorgs */ + name: 'node.inbox-reader.delay-blocks'; + type: number; + } + | { + /** erase future transactions in addition to overwriting existing ones on reorg */ + name: 'node.inbox-reader.hard-reorg'; + type: boolean; + } + | { + /** if adjust-blocks-to-read is enabled, the maximum number of blocks to read at once (default 2000) */ + name: 'node.inbox-reader.max-blocks-to-read'; + type: number; + } + | { + /** the minimum number of blocks to read at once (when caught up lowers load on L1) (default 1) */ + name: 'node.inbox-reader.min-blocks-to-read'; + type: number; + } + | { + /** mode to only read latest or safe or finalized L1 blocks. Enabling safe or finalized disables feed input and output. Defaults to latest. Takes string input, valid strings- latest, safe, finalized (default "latest") */ + name: 'node.inbox-reader.read-mode'; + type: string; + } + | { + /** if adjust-blocks-to-read is enabled, the target number of messages to read at once (default 500) */ + name: 'node.inbox-reader.target-messages-read'; + type: number; + } + | { + /** should node always try grabing lock in background */ + name: 'node.maintenance.lock.background-lock'; + type: boolean; + } + | { + /** if false, always treat this as locked and don't write the lock to redis (default true) */ + name: 'node.maintenance.lock.enable'; + type: boolean; + } + | { + /** key for lock */ + name: 'node.maintenance.lock.key'; + type: string; + } + | { + /** how long lock is held (default 1m0s) */ + name: 'node.maintenance.lock.lockout-duration'; + type: string; + } + | { + /** this node's id prefix when acquiring the lock (optional) */ + name: 'node.maintenance.lock.my-id'; + type: string; + } + | { + /** how long between consecutive calls to redis (default 10s) */ + name: 'node.maintenance.lock.refresh-duration'; + type: string; + } + | { + /** UTC 24-hour time of day to run maintenance (currently only db compaction) at (e.g. 15:00) */ + name: 'node.maintenance.time-of-day'; + type: string; + } + | { + /** enable message pruning (default true) */ + name: 'node.message-pruner.enable'; + type: boolean; + } + | { + /** min number of batches not pruned (default 2) */ + name: 'node.message-pruner.min-batches-left'; + type: number; + } + | { + /** interval for running message pruner (default 1m0s) */ + name: 'node.message-pruner.prune-interval'; + type: string; + } + | { + /** Dangerous! only meant to be used by system tests */ + name: 'node.parent-chain-reader.dangerous.wait-for-tx-approval-safe-poll'; + type: string; + } + | { + /** enable reader connection (default true) */ + name: 'node.parent-chain-reader.enable'; + type: boolean; + } + | { + /** warns if the latest l1 block is at least this old (default 5m0s) */ + name: 'node.parent-chain-reader.old-header-timeout'; + type: string; + } + | { + /** interval when polling endpoint (default 15s) */ + name: 'node.parent-chain-reader.poll-interval'; + type: string; + } + | { + /** do not attempt to subscribe to header events */ + name: 'node.parent-chain-reader.poll-only'; + type: boolean; + } + | { + /** interval for subscribe error (default 5m0s) */ + name: 'node.parent-chain-reader.subscribe-err-interval'; + type: string; + } + | { + /** timeout when waiting for a transaction (default 5m0s) */ + name: 'node.parent-chain-reader.tx-timeout'; + type: string; + } + | { + /** use l1 data about finalized/safe blocks (default true) */ + name: 'node.parent-chain-reader.use-finality-data'; + type: boolean; + } + | { + /** if non-empty, launch an HTTP service binding to this address that returns status code 200 when chosen and 503 otherwise */ + name: 'node.seq-coordinator.chosen-healthcheck-addr'; + type: string; + } + | { + /** enable sequence coordinator */ + name: 'node.seq-coordinator.enable'; + type: boolean; + } + | { + /** the maximum amount of time to spend waiting for another sequencer to accept the lockout when handing it off on shutdown or db compaction (default 30s) */ + name: 'node.seq-coordinator.handoff-timeout'; + type: string; + } + | { + /** (default 1m0s) */ + name: 'node.seq-coordinator.lockout-duration'; + type: string; + } + | { + /** (default 30s) */ + name: 'node.seq-coordinator.lockout-spare'; + type: string; + } + | { + /** will only be marked as wanting the lockout if not too far behind (default 2000) */ + name: 'node.seq-coordinator.msg-per-poll'; + type: number; + } + | { + /** url for this sequencer if it is the chosen (default "") */ + name: 'node.seq-coordinator.my-url'; + type: string; + } + | { + /** the Redis URL to coordinate via */ + name: 'node.seq-coordinator.redis-url'; + type: string; + } + | { + /** the number of times to retry releasing the wants lockout and chosen one status on shutdown (default 4) */ + name: 'node.seq-coordinator.release-retries'; + type: number; + } + | { + /** (default 50ms) */ + name: 'node.seq-coordinator.retry-interval'; + type: string; + } + | { + /** if non-zero will add delay after transferring control (default 5s) */ + name: 'node.seq-coordinator.safe-shutdown-delay'; + type: string; + } + | { + /** (default 24h0m0s) */ + name: 'node.seq-coordinator.seq-num-duration'; + type: string; + } + | { + /** accept verified message from sequencer (default true) */ + name: 'node.seq-coordinator.signer.ecdsa.accept-sequencer'; + type: boolean; + } + | { + /** a list of allowed addresses */ + name: 'node.seq-coordinator.signer.ecdsa.allowed-addresses'; + type: string[]; + } + | { + /** accept empty as valid signature (default true) */ + name: 'node.seq-coordinator.signer.ecdsa.dangerous.accept-missing'; + type: boolean; + } + | { + /** if to fall back to symmetric hmac */ + name: 'node.seq-coordinator.signer.symmetric-fallback'; + type: boolean; + } + | { + /** if to sign with symmetric hmac */ + name: 'node.seq-coordinator.signer.symmetric-sign'; + type: boolean; + } + | { + /** disable message signature verification */ + name: 'node.seq-coordinator.signer.symmetric.dangerous.disable-signature-verification'; + type: boolean; + } + | { + /** a fallback key used for message verification */ + name: 'node.seq-coordinator.signer.symmetric.fallback-verification-key'; + type: string; + } + | { + /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ + name: 'node.seq-coordinator.signer.symmetric.signing-key'; + type: string; + } + | { + /** (default 250ms) */ + name: 'node.seq-coordinator.update-interval'; + type: string; + } + | { + /** enable sequencer */ + name: 'node.sequencer'; + type: boolean; + } + | { + /** confirmation blocks (default 12) */ + name: 'node.staker.confirmation-blocks'; + type: number; + } + | { + /** validator smart contract wallet public address */ + name: 'node.staker.contract-wallet-address'; + type: string; + } + | { + /** DANGEROUS! make assertions even when the wasm module root is wrong */ + name: 'node.staker.dangerous.ignore-rollup-wasm-module-root'; + type: boolean; + } + | { + /** DANGEROUS! allows running an L1 validator without a block validator */ + name: 'node.staker.dangerous.without-block-validator'; + type: boolean; + } + | { + /** if true, don't put transactions in the mempool that spend a total greater than the batch poster's balance (default true) */ + name: 'node.staker.data-poster.allocate-mempool-balance'; + type: boolean; + } + | { + /** clear database storage */ + name: 'node.staker.data-poster.dangerous.clear-dbstorage'; + type: boolean; + } + | { + /** unit to measure the time elapsed since creation of transaction used for maximum fee cap calculation (default 10m0s) */ + name: 'node.staker.data-poster.elapsed-time-base'; + type: string; + } + | { + /** weight given to the units of time elapsed used for maximum fee cap calculation (default 10) */ + name: 'node.staker.data-poster.elapsed-time-importance'; + type: number; + } + | { + /** external signer address */ + name: 'node.staker.data-poster.external-signer.address'; + type: string; + } + | { + /** rpc client cert */ + name: 'node.staker.data-poster.external-signer.client-cert'; + type: string; + } + | { + /** rpc client private key */ + name: 'node.staker.data-poster.external-signer.client-private-key'; + type: string; + } + | { + /** external signer method (default "eth_signTransaction") */ + name: 'node.staker.data-poster.external-signer.method'; + type: string; + } + | { + /** external signer root CA */ + name: 'node.staker.data-poster.external-signer.root-ca'; + type: string; + } + | { + /** external signer url */ + name: 'node.staker.data-poster.external-signer.url'; + type: string; + } + | { + /** encodes items in a legacy way (as it was before dropping generics) */ + name: 'node.staker.data-poster.legacy-storage-encoding'; + type: boolean; + } + | { + /** mathematical formula to calculate maximum fee cap gwei the result of which would be float64. This expression is expected to be evaluated please refer https://github.com/Knetic/govaluate/blob/master/MANUAL.md to find all available mathematical operators. Currently available variables to construct the formula are BacklogOfBatches, UrgencyGWei, ElapsedTime, ElapsedTimeBase, ElapsedTimeImportance, and TargetPriceGWei (default "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei") */ + name: 'node.staker.data-poster.max-fee-cap-formula'; + type: string; + } + | { + /** the maximum number of transactions to have queued in the mempool at once (0 = unlimited) (default 1) */ + name: 'node.staker.data-poster.max-mempool-transactions'; + type: number; + } + | { + /** the maximum number of unconfirmed transactions to track at once (0 = unlimited) */ + name: 'node.staker.data-poster.max-queued-transactions'; + type: number; + } + | { + /** the maximum tip cap to post transactions at (default 5) */ + name: 'node.staker.data-poster.max-tip-cap-gwei'; + type: number; + } + | { + /** the minimum fee cap to post transactions at */ + name: 'node.staker.data-poster.min-fee-cap-gwei'; + type: number; + } + | { + /** the minimum tip cap to post transactions at (default 0.05) */ + name: 'node.staker.data-poster.min-tip-cap-gwei'; + type: number; + } + | { + /** the maximum probable reorg depth, used to determine when a transaction will no longer likely need replaced-by-fee (default 1) */ + name: 'node.staker.data-poster.nonce-rbf-soft-confs'; + type: number; + } + | { + /** disable message signature verification */ + name: 'node.staker.data-poster.redis-signer.dangerous.disable-signature-verification'; + type: boolean; + } + | { + /** a fallback key used for message verification */ + name: 'node.staker.data-poster.redis-signer.fallback-verification-key'; + type: string; + } + | { + /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ + name: 'node.staker.data-poster.redis-signer.signing-key'; + type: string; + } + | { + /** comma-separated list of durations since first posting to attempt a replace-by-fee (default "5m,10m,20m,30m,1h,2h,4h,6h,8h,12h,16h,18h,20h,22h") */ + name: 'node.staker.data-poster.replacement-times'; + type: string; + } + | { + /** the target price to use for maximum fee cap calculation (default 60) */ + name: 'node.staker.data-poster.target-price-gwei'; + type: number; + } + | { + /** the urgency to use for maximum fee cap calculation (default 2) */ + name: 'node.staker.data-poster.urgency-gwei'; + type: number; + } + | { + /** uses database storage when enabled (default true) */ + name: 'node.staker.data-poster.use-db-storage'; + type: boolean; + } + | { + /** uses noop storage, it doesn't store anything */ + name: 'node.staker.data-poster.use-noop-storage'; + type: boolean; + } + | { + /** only treat a transaction as confirmed after L1 finality has been achieved (recommended) (default true) */ + name: 'node.staker.data-poster.wait-for-l1-finality'; + type: boolean; + } + | { + /** disable validator challenge */ + name: 'node.staker.disable-challenge'; + type: boolean; + } + | { + /** enable validator (default true) */ + name: 'node.staker.enable'; + type: boolean; + } + | { + /** use this much more gas than estimation says is necessary to post transactions (default 50000) */ + name: 'node.staker.extra-gas'; + type: number; + } + | { + /** The gas refunder contract address (optional) */ + name: 'node.staker.gas-refunder-address'; + type: string; + } + | { + /** if configured with the makeNodes strategy, how often to create new assertions (bypassed in case of a dispute) (default 1h0m0s) */ + name: 'node.staker.make-assertion-interval'; + type: string; + } + | { + /** only create smart wallet contract and exit */ + name: 'node.staker.only-create-wallet-contract'; + type: boolean; + } + | { + /** account to use (default is first account in keystore) */ + name: 'node.staker.parent-chain-wallet.account'; + type: string; + } + | { + /** if true, creates new key then exits */ + name: 'node.staker.parent-chain-wallet.only-create-key'; + type: boolean; + } + | { + /** wallet passphrase (default "PASSWORD_NOT_SET") */ + name: 'node.staker.parent-chain-wallet.password'; + type: string; + } + | { + /** pathname for wallet (default "validator-wallet") */ + name: 'node.staker.parent-chain-wallet.pathname'; + type: string; + } + | { + /** private key for wallet */ + name: 'node.staker.parent-chain-wallet.private-key'; + type: string; + } + | { + /** high gas delay blocks */ + name: 'node.staker.posting-strategy.high-gas-delay-blocks'; + type: number; + } + | { + /** high gas threshold */ + name: 'node.staker.posting-strategy.high-gas-threshold'; + type: number; + } + | { + /** redis url for L1 validator */ + name: 'node.staker.redis-url'; + type: string; + } + | { + /** how often the L1 validator should check the status of the L1 rollup and maybe take action with its stake (default 1m0s) */ + name: 'node.staker.staker-interval'; + type: string; + } + | { + /** assume staked nodes are valid (default true) */ + name: 'node.staker.start-validation-from-staked'; + type: boolean; + } + | { + /** L1 validator strategy, either watchtower, defensive, stakeLatest, or makeNodes (default "Watchtower") */ + name: 'node.staker.strategy'; + type: string; + } + | { + /** use a smart contract wallet instead of an EOA address */ + name: 'node.staker.use-smart-contract-wallet'; + type: boolean; + } + | { + /** allowed lag between messages read and blocks built (default 20) */ + name: 'node.sync-monitor.block-build-lag'; + type: number; + } + | { + /** allowed lag between messages read from sequencer inbox and blocks built */ + name: 'node.sync-monitor.block-build-sequencer-inbox-lag'; + type: number; + } + | { + /** allowed lag between local and remote messages (default 15) */ + name: 'node.sync-monitor.coordinator-msg-lag'; + type: number; + } + | { + /** wait for block validator to complete before returning finalized block number */ + name: 'node.sync-monitor.finalized-block-wait-for-block-validator'; + type: boolean; + } + | { + /** wait for block validator to complete before returning safe block number */ + name: 'node.sync-monitor.safe-block-wait-for-block-validator'; + type: boolean; + } + | { + /** delay when polling calls to execute messages (default 100ms) */ + name: 'node.transaction-streamer.execute-message-loop-delay'; + type: string; + } + | { + /** maximum cache of pending broadcaster messages (default 50000) */ + name: 'node.transaction-streamer.max-broadcaster-queue-size'; + type: number; + } + | { + /** maximum number of messages to attempt to resequence on reorg (0 = never resequence, -1 = always resequence) (default 1024) */ + name: 'node.transaction-streamer.max-reorg-resequence-depth'; + type: number; + } + | { + /** P2P bootnodes */ + name: 'p2p.bootnodes'; + type: string[]; + } + | { + /** P2P bootnodes v5 */ + name: 'p2p.bootnodes-v5'; + type: string[]; + } + | { + /** P2P discovery v4 */ + name: 'p2p.discovery-v4'; + type: boolean; + } + | { + /** P2P discovery v5 */ + name: 'p2p.discovery-v5'; + type: boolean; + } + | { + /** P2P listen address */ + name: 'p2p.listen-addr'; + type: string; + } + | { + /** P2P max peers (default 50) */ + name: 'p2p.max-peers'; + type: number; + } + | { + /** P2P no dial (default true) */ + name: 'p2p.no-dial'; + type: boolean; + } + | { + /** P2P no discovery (default true) */ + name: 'p2p.no-discovery'; + type: boolean; + } + | { + /** limit size of arguments in log entries (default 2048) */ + name: 'parent-chain.connection.arg-log-limit'; + type: number; + } + | { + /** how long to wait for initial connection (default 1m0s) */ + name: 'parent-chain.connection.connection-wait'; + type: string; + } + | { + /** path to file with jwtsecret for validation - ignored if url is self or self-auth */ + name: 'parent-chain.connection.jwtsecret'; + type: string; + } + | { + /** number of retries in case of failure(0 mean one attempt) (default 2) */ + name: 'parent-chain.connection.retries'; + type: number; + } + | { + /** delay between retries */ + name: 'parent-chain.connection.retry-delay'; + type: string; + } + | { + /** Errors matching this regular expression are automatically retried */ + name: 'parent-chain.connection.retry-errors'; + type: string; + } + | { + /** per-response timeout (0-disabled) (default 1m0s) */ + name: 'parent-chain.connection.timeout'; + type: string; + } + | { + /** url of server, use self for loopback websocket, self-auth for loopback with authentication */ + name: 'parent-chain.connection.url'; + type: string; + } + | { + /** if set other than 0, will be used to validate database and L1 connection */ + name: 'parent-chain.id'; + type: number; + } + | { + /** account to use (default is first account in keystore) */ + name: 'parent-chain.wallet.account'; + type: string; + } + | { + /** if true, creates new key then exits */ + name: 'parent-chain.wallet.only-create-key'; + type: boolean; + } + | { + /** wallet passphrase (default "PASSWORD_NOT_SET") */ + name: 'parent-chain.wallet.password'; + type: string; + } + | { + /** pathname for wallet (default "wallet") */ + name: 'parent-chain.wallet.pathname'; + type: string; + } + | { + /** private key for wallet */ + name: 'parent-chain.wallet.private-key'; + type: string; + } + | { + /** directory of ancient where the chain freezer can be opened */ + name: 'persistent.ancient'; + type: string; + } + | { + /** directory to store chain state */ + name: 'persistent.chain'; + type: string; + } + | { + /** backing database implementation to use ('leveldb' or 'pebble') (default "leveldb") */ + name: 'persistent.db-engine'; + type: string; + } + | { + /** directory to store global config (default ".arbitrum") */ + name: 'persistent.global-config'; + type: string; + } + | { + /** number of file descriptor handles to use for the database (default 512) */ + name: 'persistent.handles'; + type: number; + } + | { + /** directory to store log file */ + name: 'persistent.log-dir'; + type: string; + } + | { + /** enable pprof */ + name: 'pprof'; + type: boolean; + } + | { + /** pprof server address (default "127.0.0.1") */ + name: 'pprof-cfg.addr'; + type: string; + } + | { + /** pprof server port (default 6071) */ + name: 'pprof-cfg.port'; + type: number; + } + | { + /** the maximum number of requests in a batch (0 means no limit) (default 1000) */ + name: 'rpc.batch-request-limit'; + type: number; + } + | { + /** the maximum response size for a JSON-RPC request measured in bytes (0 means no limit) (default 10000000) */ + name: 'rpc.max-batch-response-size'; + type: number; + } + | { + /** validate is an authenticated API (default true) */ + name: 'validation.api-auth'; + type: boolean; + } + | { + /** validate is a public API */ + name: 'validation.api-public'; + type: boolean; + } + | { + /** timeout before discarding execution run (default 15m0s) */ + name: 'validation.arbitrator.execution-run-timeout'; + type: string; + } + | { + /** how many machines to store in cache while working on a challenge (should be even) (default 4) */ + name: 'validation.arbitrator.execution.cached-challenge-machines'; + type: number; + } + | { + /** initial steps between machines (default 100000) */ + name: 'validation.arbitrator.execution.initial-steps'; + type: number; + } + | { + /** path to write machines to (default "./target/output") */ + name: 'validation.arbitrator.output-path'; + type: string; + } + | { + /** number of concurrent validation threads */ + name: 'validation.arbitrator.workers'; + type: number; + } + | { + /** use Cranelift instead of LLVM when validating blocks using the jit-accelerated block validator (default true) */ + name: 'validation.jit.cranelift'; + type: boolean; + } + | { + /** if memory used by a jit wasm exceeds this limit, a warning is logged (default 4294967296) */ + name: 'validation.jit.wasm-memory-usage-limit'; + type: number; + } + | { + /** number of concurrent validation threads */ + name: 'validation.jit.workers'; + type: number; + } + | { + /** use jit for validation (default true) */ + name: 'validation.use-jit'; + type: boolean; + } + | { + /** list of WASM module roots to check if the on-chain WASM module root belongs to on node startup */ + name: 'validation.wasm.allowed-wasm-module-roots'; + type: string[]; + } + | { + /** enable check for compatibility of on-chain WASM module root with node (default true) */ + name: 'validation.wasm.enable-wasmroots-check'; + type: boolean; + } + | { + /** path to machine folders, each containing wasm files (machine.wavm.br, replay.wasm) */ + name: 'validation.wasm.root-path'; + type: string; + } + | { + /** WS-RPC server listening interface */ + name: 'ws.addr'; + type: string; + } + | { + /** APIs offered over the WS-RPC interface (default [net,web3,eth,arb]) */ + name: 'ws.api'; + type: string[]; + } + | { + /** expose private api via websocket */ + name: 'ws.expose-all'; + type: boolean; + } + | { + /** Origins from which to accept websockets requests */ + name: 'ws.origins'; + type: string[]; + } + | { + /** WS-RPC server listening port (default 8548) */ + name: 'ws.port'; + type: number; + } + | { + /** WS path path prefix on which JSON-RPC is served. Use '/' to serve on all paths */ + name: 'ws.rpcprefix'; + type: string; + }; From 205b094d4c6ccedb0669ff5f61b82242a704b604 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Tue, 27 Feb 2024 19:20:22 +0100 Subject: [PATCH 06/24] add tests --- .../nodeConfigBuilder.unit.test.ts.snap | 55 +++++++++++++++++++ src/nodeConfigBuilder.ts | 13 +---- src/nodeConfigBuilder.unit.test.ts | 13 +++++ 3 files changed, 69 insertions(+), 12 deletions(-) create mode 100644 src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap create mode 100644 src/nodeConfigBuilder.unit.test.ts diff --git a/src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap b/src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap new file mode 100644 index 00000000..8dd80602 --- /dev/null +++ b/src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap @@ -0,0 +1,55 @@ +// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html + +exports[`creates node config with defaults 1`] = ` +{ + "execution": { + "caching": { + "archive": true, + }, + "forwarding-target": "", + "sequencer": { + "enable": true, + "max-block-speed": "250ms", + "max-tx-data-size": 85000, + }, + }, + "http": { + "addr": "0.0.0.0", + "api": [ + "eth", + "net", + "web3", + "arb", + "debug", + ], + "corsdomain": [ + "*", + ], + "port": 8449, + "vhosts": [ + "*", + ], + }, + "node": { + "batch-poster": { + "enable": true, + "max-size": 90000, + }, + "dangerous": { + "no-sequencer-coordinator": true, + }, + "delayed-sequencer": { + "enable": true, + "finalize-distance": 1, + "use-merge-finality": false, + }, + "sequencer": true, + "staker": { + "enable": true, + "strategy": "MakeNodes", + }, + }, +} +`; + +exports[`creates node config without defaults 1`] = `{}`; diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index 42f8194a..d6642f58 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -34,7 +34,7 @@ class NodeConfigBuilder { name: TName, value: NodeConfigOptionValue, ): NodeConfigBuilder { - throw new Error(`not yet implemented`); + return this; } build(): NodeConfig { @@ -55,14 +55,3 @@ export function createNodeConfigBuilder(params?: CreateNodeConfigBuilderParams): return new NodeConfigBuilder(nodeConfigBuilderDefaults); } - -const nodeConfig = createNodeConfigBuilder() - // - .set(config.auth.addr, '127.0.0.1') - .set(config.auth.api, ['eth']) - .set('chain.name', 'asdf') - .set('chain.info-json', 'asdf') - .set('parent-chain.connection.url', '') - .set('node.batch-poster.parent-chain-wallet.private-key', '') - .set('node.staker.parent-chain-wallet.private-key', '') - .build(); diff --git a/src/nodeConfigBuilder.unit.test.ts b/src/nodeConfigBuilder.unit.test.ts new file mode 100644 index 00000000..c416a981 --- /dev/null +++ b/src/nodeConfigBuilder.unit.test.ts @@ -0,0 +1,13 @@ +import { it, expect } from 'vitest'; + +import { createNodeConfigBuilder } from './nodeConfigBuilder'; + +it('creates node config with defaults', () => { + const nodeConfig = createNodeConfigBuilder().build(); + expect(nodeConfig).toMatchSnapshot(); +}); + +it('creates node config without defaults', () => { + const nodeConfig = createNodeConfigBuilder({ withoutDefaults: true }).build(); + expect(nodeConfig).toMatchSnapshot(); +}); From 45230b6e3df288dcce282e7ddffa82474aad08a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dragi=C5=A1a=20Spasojevi=C4=87?= Date: Wed, 28 Feb 2024 11:45:07 +0100 Subject: [PATCH 07/24] smol cleanup --- src/nodeConfigBuilder.ts | 9 +++++---- src/nodeConfigBuilder.unit.test.ts | 2 +- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index d6642f58..72cea1dd 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -42,14 +42,15 @@ class NodeConfigBuilder { } } -type CreateNodeConfigBuilderParams = { - withoutDefaults: boolean; +export type CreateNodeConfigBuilderParams = { + withDefaults?: boolean; + withDataAvailability?: boolean; }; export function createNodeConfigBuilder(params?: CreateNodeConfigBuilderParams): NodeConfigBuilder { - const withoutDefaults = params?.withoutDefaults ?? false; + const withDefaults = params?.withDefaults ?? true; - if (withoutDefaults) { + if (!withDefaults) { return new NodeConfigBuilder(); } diff --git a/src/nodeConfigBuilder.unit.test.ts b/src/nodeConfigBuilder.unit.test.ts index c416a981..84aa7dc7 100644 --- a/src/nodeConfigBuilder.unit.test.ts +++ b/src/nodeConfigBuilder.unit.test.ts @@ -8,6 +8,6 @@ it('creates node config with defaults', () => { }); it('creates node config without defaults', () => { - const nodeConfig = createNodeConfigBuilder({ withoutDefaults: true }).build(); + const nodeConfig = createNodeConfigBuilder({ withDefaults: false }).build(); expect(nodeConfig).toMatchSnapshot(); }); From 71939151f419d7f071cb4df0e31937cd194d8e16 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Thu, 29 Feb 2024 10:31:07 +0100 Subject: [PATCH 08/24] add data availability defaults --- .../nodeConfigBuilder.unit.test.ts.snap | 66 ++++++++++++++++ src/nodeConfigBuilder.ts | 4 +- src/nodeConfigBuilder.unit.test.ts | 5 ++ src/nodeConfigBuilderDefaults.ts | 79 +++++++++++++++++++ 4 files changed, 152 insertions(+), 2 deletions(-) diff --git a/src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap b/src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap index 8dd80602..116d4330 100644 --- a/src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap +++ b/src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap @@ -52,4 +52,70 @@ exports[`creates node config with defaults 1`] = ` } `; +exports[`creates node config with defaults including data availability 1`] = ` +{ + "execution": { + "caching": { + "archive": true, + }, + "forwarding-target": "", + "sequencer": { + "enable": true, + "max-block-speed": "250ms", + "max-tx-data-size": 85000, + }, + }, + "http": { + "addr": "0.0.0.0", + "api": [ + "eth", + "net", + "web3", + "arb", + "debug", + ], + "corsdomain": [ + "*", + ], + "port": 8449, + "vhosts": [ + "*", + ], + }, + "node": { + "batch-poster": { + "enable": true, + "max-size": 90000, + }, + "dangerous": { + "no-sequencer-coordinator": true, + }, + "data-availability": { + "enable": true, + "rest-aggregator": { + "enable": true, + "urls": [ + "http://localhost:9877", + ], + }, + "rpc-aggregator": { + "assumed-honest": 1, + "backends": "[{\\"url\\":\\"http://localhost:9876\\",\\"pubkey\\":\\"YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==\\",\\"signermask\\":1}]", + "enable": true, + }, + }, + "delayed-sequencer": { + "enable": true, + "finalize-distance": 1, + "use-merge-finality": false, + }, + "sequencer": true, + "staker": { + "enable": true, + "strategy": "MakeNodes", + }, + }, +} +`; + exports[`creates node config without defaults 1`] = `{}`; diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index 72cea1dd..dfb83455 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -1,5 +1,5 @@ import { NodeConfig, NodeConfigOption } from './types/NodeConfig.generated'; -import { nodeConfigBuilderDefaults } from './nodeConfigBuilderDefaults'; +import { getNodeConfigBuilderDefaults } from './nodeConfigBuilderDefaults'; // todo: is there a way to make jsdoc readable when working with the builder? @@ -54,5 +54,5 @@ export function createNodeConfigBuilder(params?: CreateNodeConfigBuilderParams): return new NodeConfigBuilder(); } - return new NodeConfigBuilder(nodeConfigBuilderDefaults); + return new NodeConfigBuilder(getNodeConfigBuilderDefaults(params)); } diff --git a/src/nodeConfigBuilder.unit.test.ts b/src/nodeConfigBuilder.unit.test.ts index 84aa7dc7..b2c7c7d8 100644 --- a/src/nodeConfigBuilder.unit.test.ts +++ b/src/nodeConfigBuilder.unit.test.ts @@ -7,6 +7,11 @@ it('creates node config with defaults', () => { expect(nodeConfig).toMatchSnapshot(); }); +it('creates node config with defaults including data availability', () => { + const nodeConfig = createNodeConfigBuilder({ withDataAvailability: true }).build(); + expect(nodeConfig).toMatchSnapshot(); +}); + it('creates node config without defaults', () => { const nodeConfig = createNodeConfigBuilder({ withDefaults: false }).build(); expect(nodeConfig).toMatchSnapshot(); diff --git a/src/nodeConfigBuilderDefaults.ts b/src/nodeConfigBuilderDefaults.ts index dd69d92c..6f4bb063 100644 --- a/src/nodeConfigBuilderDefaults.ts +++ b/src/nodeConfigBuilderDefaults.ts @@ -1,4 +1,11 @@ import { NodeConfig } from './types/NodeConfig.generated'; +import { NodeConfigDataAvailabilityRpcAggregatorBackendsJson } from './types/NodeConfig'; + +function stringifyBackendsJson( + backendsJson: NodeConfigDataAvailabilityRpcAggregatorBackendsJson, +): string { + return JSON.stringify(backendsJson); +} export const nodeConfigBuilderDefaults: NodeConfig = { http: { @@ -39,3 +46,75 @@ export const nodeConfigBuilderDefaults: NodeConfig = { }, }, }; + +export type GetNodeConfigBuilderDefaultsParams = { + withDataAvailability?: boolean; +}; + +export function getNodeConfigBuilderDefaults( + params?: GetNodeConfigBuilderDefaultsParams, +): NodeConfig { + let defaults: NodeConfig = { + http: { + addr: '0.0.0.0', + port: 8449, + vhosts: ['*'], + corsdomain: ['*'], + api: ['eth', 'net', 'web3', 'arb', 'debug'], + }, + node: { + 'sequencer': true, + 'delayed-sequencer': { + 'enable': true, + 'use-merge-finality': false, + 'finalize-distance': 1, + }, + 'batch-poster': { + 'max-size': 90000, + 'enable': true, + }, + 'staker': { + enable: true, + strategy: 'MakeNodes', + }, + 'dangerous': { + 'no-sequencer-coordinator': true, + }, + }, + execution: { + 'forwarding-target': '', + 'sequencer': { + 'enable': true, + 'max-tx-data-size': 85000, + 'max-block-speed': '250ms', + }, + 'caching': { + archive: true, + }, + }, + }; + + if (params?.withDataAvailability ?? false) { + defaults.node!['data-availability'] = { + 'enable': true, + 'rest-aggregator': { + enable: true, + urls: ['http://localhost:9877'], + }, + 'rpc-aggregator': { + 'enable': true, + 'assumed-honest': 1, + 'backends': stringifyBackendsJson([ + { + url: 'http://localhost:9876', + pubkey: + 'YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==', + signermask: 1, + }, + ]), + }, + }; + } + + return defaults; +} From 9abd682cd4f652294731db7c44b454a12f8b35c4 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Thu, 29 Feb 2024 16:41:45 +0100 Subject: [PATCH 09/24] update --- src/types/NodeConfig.generated.ts | 31 ++++++++++++++++++------------- 1 file changed, 18 insertions(+), 13 deletions(-) diff --git a/src/types/NodeConfig.generated.ts b/src/types/NodeConfig.generated.ts index e19ed801..e5593149 100644 --- a/src/types/NodeConfig.generated.ts +++ b/src/types/NodeConfig.generated.ts @@ -3,7 +3,7 @@ // THIS FILE IS AUTOMATICALLY GENERATED AND SHOULD NOT BE EDITED MANUALLY // // IMAGE: offchainlabs/nitro-node:v2.3.0-3e14543 -// TIMESTAMP: 2024-02-29T09:03:31.210Z +// TIMESTAMP: 2024-02-29T15:41:39.801Z // // --- /** Nitro node configuration object */ @@ -29,7 +29,7 @@ export type NodeConfig = { 'end-block'?: number; /** mode to run the blocks-reexecutor on. Valid modes full and random. full - execute all the blocks in the given range. random - execute a random sample range of blocks with in a given range (default "random") */ 'mode'?: string; - /** number of threads to parallelize blocks re-execution (default 10) */ + /** number of threads to parallelize blocks re-execution (default 12) */ 'room'?: number; /** first block number of the block range for re-execution */ 'start-block'?: number; @@ -488,7 +488,7 @@ export type NodeConfig = { 'memory-free-limit'?: string; /** pending upgrade wasm module root to additionally validate (hash, 'latest' or empty) (default "latest") */ 'pending-upgrade-module-root'?: string; - /** record that many blocks ahead of validation (larger footprint) (default 20) */ + /** record that many blocks ahead of validation (larger footprint) (default 24) */ 'prerecorded-blocks'?: number; /** poll time to check validations (default 1s) */ 'validation-poll'?: string; @@ -2089,16 +2089,6 @@ export type NodeConfigOption = name: 'node.batch-poster.wait-for-max-delay'; type: boolean; } - | { - /** Beacon Chain url to use for fetching blobs */ - name: 'node.blob-client.beacon-chain-url'; - type: string; - } - | { - /** Full path of the directory to save fetched blobs */ - name: 'node.blob-client.blob-directory'; - type: string; - } | { /** current wasm module root ('current' read from chain, 'latest' from machines/latest dir, or provide hash) (default "current") */ name: 'node.block-validator.current-module-root'; @@ -2189,6 +2179,11 @@ export type NodeConfigOption = name: 'node.block-validator.validation-server.url'; type: string; } + | { + /** DANGEROUS! disables the EIP-4844 blob reader, which is necessary to read batches */ + name: 'node.dangerous.disable-blob-reader'; + type: boolean; + } | { /** DANGEROUS! disables listening to L1. To be used in test nodes only */ name: 'node.dangerous.no-l1-listener'; @@ -3144,6 +3139,16 @@ export type NodeConfigOption = name: 'p2p.no-discovery'; type: boolean; } + | { + /** Beacon Chain RPC URL to use for fetching blobs (normally on port 3500) */ + name: 'parent-chain.blob-client.beacon-url'; + type: string; + } + | { + /** Full path of the directory to save fetched blobs */ + name: 'parent-chain.blob-client.blob-directory'; + type: string; + } | { /** limit size of arguments in log entries (default 2048) */ name: 'parent-chain.connection.arg-log-limit'; From f79ad29d397f53bb37a2107a5178a61926d0a4e5 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Thu, 29 Feb 2024 16:48:09 +0100 Subject: [PATCH 10/24] change name to key --- src/nodeConfigBuilder.ts | 14 +- src/scripts/generateNodeConfigType.ts | 5 +- src/types/NodeConfig.generated.ts | 912 +++++++++++++------------- 3 files changed, 466 insertions(+), 465 deletions(-) diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index dfb83455..c9e37ec7 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -3,11 +3,11 @@ import { getNodeConfigBuilderDefaults } from './nodeConfigBuilderDefaults'; // todo: is there a way to make jsdoc readable when working with the builder? -type NodeConfigOptionName = NodeConfigOption['name']; +export type NodeConfigOptionKey = NodeConfigOption['key']; -type NodeConfigOptionValue = Extract< +export type NodeConfigOptionGetType = Extract< NodeConfigOption, - { name: TName } + { name: TKey } >['type']; const config = { @@ -23,16 +23,16 @@ const config = { }, } as const; -class NodeConfigBuilder { +export class NodeConfigBuilder { private nodeConfig: NodeConfig; constructor(initialNodeConfig?: NodeConfig) { this.nodeConfig = initialNodeConfig ?? {}; } - set( - name: TName, - value: NodeConfigOptionValue, + set( + key: TKey, + value: NodeConfigOptionGetType, ): NodeConfigBuilder { return this; } diff --git a/src/scripts/generateNodeConfigType.ts b/src/scripts/generateNodeConfigType.ts index f2d02119..69a6bbc8 100644 --- a/src/scripts/generateNodeConfigType.ts +++ b/src/scripts/generateNodeConfigType.ts @@ -195,12 +195,13 @@ function main() { sourceFile.addTypeAlias({ name: 'NodeConfigOption', type: unionType( - // @ts-ignore not sure why ts-morph is acting weird here + // not sure why ts-morph is acting weird here + // @ts-ignore ...cliOptions.map((option) => objectType({ properties: [ { - name: 'name', + name: 'key', type: `"${option.name}"`, docs: option.docs, }, diff --git a/src/types/NodeConfig.generated.ts b/src/types/NodeConfig.generated.ts index e5593149..b48c3dd1 100644 --- a/src/types/NodeConfig.generated.ts +++ b/src/types/NodeConfig.generated.ts @@ -3,7 +3,7 @@ // THIS FILE IS AUTOMATICALLY GENERATED AND SHOULD NOT BE EDITED MANUALLY // // IMAGE: offchainlabs/nitro-node:v2.3.0-3e14543 -// TIMESTAMP: 2024-02-29T15:41:39.801Z +// TIMESTAMP: 2024-02-29T15:44:11.800Z // // --- /** Nitro node configuration object */ @@ -1101,2276 +1101,2276 @@ export type NodeConfig = { export type NodeConfigOption = | { /** AUTH-RPC server listening interface (default "127.0.0.1") */ - name: 'auth.addr'; + key: 'auth.addr'; type: string; } | { /** APIs offered over the AUTH-RPC interface (default [validation]) */ - name: 'auth.api'; + key: 'auth.api'; type: string[]; } | { /** Path to file holding JWT secret (32B hex) */ - name: 'auth.jwtsecret'; + key: 'auth.jwtsecret'; type: string; } | { /** Origins from which to accept AUTH requests (default [localhost]) */ - name: 'auth.origins'; + key: 'auth.origins'; type: string[]; } | { /** AUTH-RPC server listening port (default 8549) */ - name: 'auth.port'; + key: 'auth.port'; type: number; } | { /** minimum number of blocks to execute per thread. When mode is random this acts as the size of random block range sample (default 10000) */ - name: 'blocks-reexecutor.blocks-per-thread'; + key: 'blocks-reexecutor.blocks-per-thread'; type: number; } | { /** enables re-execution of a range of blocks against historic state */ - name: 'blocks-reexecutor.enable'; + key: 'blocks-reexecutor.enable'; type: boolean; } | { /** last block number of the block range for re-execution */ - name: 'blocks-reexecutor.end-block'; + key: 'blocks-reexecutor.end-block'; type: number; } | { /** mode to run the blocks-reexecutor on. Valid modes full and random. full - execute all the blocks in the given range. random - execute a random sample range of blocks with in a given range (default "random") */ - name: 'blocks-reexecutor.mode'; + key: 'blocks-reexecutor.mode'; type: string; } | { /** number of threads to parallelize blocks re-execution (default 12) */ - name: 'blocks-reexecutor.room'; + key: 'blocks-reexecutor.room'; type: number; } | { /** first block number of the block range for re-execution */ - name: 'blocks-reexecutor.start-block'; + key: 'blocks-reexecutor.start-block'; type: number; } | { /** account to use (default is first account in keystore) */ - name: 'chain.dev-wallet.account'; + key: 'chain.dev-wallet.account'; type: string; } | { /** if true, creates new key then exits */ - name: 'chain.dev-wallet.only-create-key'; + key: 'chain.dev-wallet.only-create-key'; type: boolean; } | { /** wallet passphrase (default "PASSWORD_NOT_SET") */ - name: 'chain.dev-wallet.password'; + key: 'chain.dev-wallet.password'; type: string; } | { /** pathname for wallet */ - name: 'chain.dev-wallet.pathname'; + key: 'chain.dev-wallet.pathname'; type: string; } | { /** private key for wallet */ - name: 'chain.dev-wallet.private-key'; + key: 'chain.dev-wallet.private-key'; type: string; } | { /** L2 chain ID (determines Arbitrum network) */ - name: 'chain.id'; + key: 'chain.id'; type: number; } | { /** L2 chain info json files */ - name: 'chain.info-files'; + key: 'chain.info-files'; type: string[]; } | { /** path to save temp downloaded file (default "/tmp/") */ - name: 'chain.info-ipfs-download-path'; + key: 'chain.info-ipfs-download-path'; type: string; } | { /** url to download chain info file */ - name: 'chain.info-ipfs-url'; + key: 'chain.info-ipfs-url'; type: string; } | { /** L2 chain info in json string format */ - name: 'chain.info-json'; + key: 'chain.info-json'; type: string; } | { /** L2 chain name (determines Arbitrum network) */ - name: 'chain.name'; + key: 'chain.name'; type: string; } | { /** print out currently active configuration file */ - name: 'conf.dump'; + key: 'conf.dump'; type: boolean; } | { /** environment variables with given prefix will be loaded as configuration values */ - name: 'conf.env-prefix'; + key: 'conf.env-prefix'; type: string; } | { /** name of configuration file */ - name: 'conf.file'; + key: 'conf.file'; type: string[]; } | { /** how often to reload configuration (0=disable periodic reloading) */ - name: 'conf.reload-interval'; + key: 'conf.reload-interval'; type: string; } | { /** S3 access key */ - name: 'conf.s3.access-key'; + key: 'conf.s3.access-key'; type: string; } | { /** S3 bucket */ - name: 'conf.s3.bucket'; + key: 'conf.s3.bucket'; type: string; } | { /** S3 object key */ - name: 'conf.s3.object-key'; + key: 'conf.s3.object-key'; type: string; } | { /** S3 region */ - name: 'conf.s3.region'; + key: 'conf.s3.region'; type: string; } | { /** S3 secret key */ - name: 'conf.s3.secret-key'; + key: 'conf.s3.secret-key'; type: string; } | { /** configuration as JSON string */ - name: 'conf.string'; + key: 'conf.string'; type: string; } | { /** retain past block state */ - name: 'execution.caching.archive'; + key: 'execution.caching.archive'; type: boolean; } | { /** minimum age of recent blocks to keep in memory (default 30m0s) */ - name: 'execution.caching.block-age'; + key: 'execution.caching.block-age'; type: string; } | { /** minimum number of recent blocks to keep in memory (default 128) */ - name: 'execution.caching.block-count'; + key: 'execution.caching.block-count'; type: number; } | { /** amount of memory in megabytes to cache database contents with (default 2048) */ - name: 'execution.caching.database-cache'; + key: 'execution.caching.database-cache'; type: number; } | { /** maximum amount of gas in blocks to skip saving state to Persistent storage (archive node only) -- warning: this option seems to cause issues */ - name: 'execution.caching.max-amount-of-gas-to-skip-state-saving'; + key: 'execution.caching.max-amount-of-gas-to-skip-state-saving'; type: number; } | { /** maximum number of blocks to skip state saving to persistent storage (archive node only) -- warning: this option seems to cause issues */ - name: 'execution.caching.max-number-of-blocks-to-skip-state-saving'; + key: 'execution.caching.max-number-of-blocks-to-skip-state-saving'; type: number; } | { /** amount of memory in megabytes to cache state snapshots with (default 400) */ - name: 'execution.caching.snapshot-cache'; + key: 'execution.caching.snapshot-cache'; type: number; } | { /** maximum gas rolled back to recover snapshot (default 300000000000) */ - name: 'execution.caching.snapshot-restore-gas-limit'; + key: 'execution.caching.snapshot-restore-gas-limit'; type: number; } | { /** amount of memory in megabytes to cache unchanged state trie nodes with (default 600) */ - name: 'execution.caching.trie-clean-cache'; + key: 'execution.caching.trie-clean-cache'; type: number; } | { /** amount of memory in megabytes to cache state diffs against disk with (larger cache lowers database growth) (default 1024) */ - name: 'execution.caching.trie-dirty-cache'; + key: 'execution.caching.trie-dirty-cache'; type: number; } | { /** maximum block processing time before trie is written to hard-disk (default 1h0m0s) */ - name: 'execution.caching.trie-time-limit'; + key: 'execution.caching.trie-time-limit'; type: string; } | { /** DANGEROUS! forces a reorg to an old block height. To be used for testing only. -1 to disable (default -1) */ - name: 'execution.dangerous.reorg-to-block'; + key: 'execution.dangerous.reorg-to-block'; type: number; } | { /** enable prefetching of blocks (default true) */ - name: 'execution.enable-prefetch-block'; + key: 'execution.enable-prefetch-block'; type: boolean; } | { /** total time to wait before cancelling connection (default 30s) */ - name: 'execution.forwarder.connection-timeout'; + key: 'execution.forwarder.connection-timeout'; type: string; } | { /** time until idle connections are closed (default 15s) */ - name: 'execution.forwarder.idle-connection-timeout'; + key: 'execution.forwarder.idle-connection-timeout'; type: string; } | { /** maximum number of idle connections to keep open (default 1) */ - name: 'execution.forwarder.max-idle-connections'; + key: 'execution.forwarder.max-idle-connections'; type: number; } | { /** the Redis URL to recomend target via */ - name: 'execution.forwarder.redis-url'; + key: 'execution.forwarder.redis-url'; type: string; } | { /** minimal time between update retries (default 100ms) */ - name: 'execution.forwarder.retry-interval'; + key: 'execution.forwarder.retry-interval'; type: string; } | { /** forwarding target update interval (default 1s) */ - name: 'execution.forwarder.update-interval'; + key: 'execution.forwarder.update-interval'; type: string; } | { /** transaction forwarding target URL, or "null" to disable forwarding (iff not sequencer) */ - name: 'execution.forwarding-target'; + key: 'execution.forwarding-target'; type: string; } | { /** Dangerous! only meant to be used by system tests */ - name: 'execution.parent-chain-reader.dangerous.wait-for-tx-approval-safe-poll'; + key: 'execution.parent-chain-reader.dangerous.wait-for-tx-approval-safe-poll'; type: string; } | { /** enable reader connection (default true) */ - name: 'execution.parent-chain-reader.enable'; + key: 'execution.parent-chain-reader.enable'; type: boolean; } | { /** warns if the latest l1 block is at least this old (default 5m0s) */ - name: 'execution.parent-chain-reader.old-header-timeout'; + key: 'execution.parent-chain-reader.old-header-timeout'; type: string; } | { /** interval when polling endpoint (default 15s) */ - name: 'execution.parent-chain-reader.poll-interval'; + key: 'execution.parent-chain-reader.poll-interval'; type: string; } | { /** do not attempt to subscribe to header events */ - name: 'execution.parent-chain-reader.poll-only'; + key: 'execution.parent-chain-reader.poll-only'; type: boolean; } | { /** interval for subscribe error (default 5m0s) */ - name: 'execution.parent-chain-reader.subscribe-err-interval'; + key: 'execution.parent-chain-reader.subscribe-err-interval'; type: string; } | { /** timeout when waiting for a transaction (default 5m0s) */ - name: 'execution.parent-chain-reader.tx-timeout'; + key: 'execution.parent-chain-reader.tx-timeout'; type: string; } | { /** use l1 data about finalized/safe blocks (default true) */ - name: 'execution.parent-chain-reader.use-finality-data'; + key: 'execution.parent-chain-reader.use-finality-data'; type: boolean; } | { /** like trie-clean-cache for the separate, recording database (used for validation) (default 16) */ - name: 'execution.recording-database.trie-clean-cache'; + key: 'execution.recording-database.trie-clean-cache'; type: number; } | { /** like trie-dirty-cache for the separate, recording database (used for validation) (default 1024) */ - name: 'execution.recording-database.trie-dirty-cache'; + key: 'execution.recording-database.trie-dirty-cache'; type: number; } | { /** list of whitelisted rpc methods */ - name: 'execution.rpc.allow-method'; + key: 'execution.rpc.allow-method'; type: string[]; } | { /** bounds the number of blocks arbdebug calls may return (default 256) */ - name: 'execution.rpc.arbdebug.block-range-bound'; + key: 'execution.rpc.arbdebug.block-range-bound'; type: number; } | { /** bounds the length of timeout queues arbdebug calls may return (default 512) */ - name: 'execution.rpc.arbdebug.timeout-queue-bound'; + key: 'execution.rpc.arbdebug.timeout-queue-bound'; type: number; } | { /** number of blocks a single bloom bit section vector holds (default 16384) */ - name: 'execution.rpc.bloom-bits-blocks'; + key: 'execution.rpc.bloom-bits-blocks'; type: number; } | { /** number of confirmation blocks before a bloom section is considered final (default 256) */ - name: 'execution.rpc.bloom-confirms'; + key: 'execution.rpc.bloom-confirms'; type: number; } | { /** url to redirect classic requests, use "error:[CODE:]MESSAGE" to return specified error instead of redirecting */ - name: 'execution.rpc.classic-redirect'; + key: 'execution.rpc.classic-redirect'; type: string; } | { /** timeout for forwarded classic requests, where 0 = no timeout */ - name: 'execution.rpc.classic-redirect-timeout'; + key: 'execution.rpc.classic-redirect-timeout'; type: string; } | { /** timeout used for eth_call (0=infinite) (default 5s) */ - name: 'execution.rpc.evm-timeout'; + key: 'execution.rpc.evm-timeout'; type: string; } | { /** max number of blocks a fee history request may cover (default 1024) */ - name: 'execution.rpc.feehistory-max-block-count'; + key: 'execution.rpc.feehistory-max-block-count'; type: number; } | { /** log filter system maximum number of cached blocks (default 32) */ - name: 'execution.rpc.filter-log-cache-size'; + key: 'execution.rpc.filter-log-cache-size'; type: number; } | { /** log filter system maximum time filters stay active (default 5m0s) */ - name: 'execution.rpc.filter-timeout'; + key: 'execution.rpc.filter-timeout'; type: string; } | { /** cap on computation gas that can be used in eth_call/estimateGas (0=infinite) (default 50000000) */ - name: 'execution.rpc.gas-cap'; + key: 'execution.rpc.gas-cap'; type: number; } | { /** maximum depth for recreating state, measured in l2 gas (0=don't recreate state, -1=infinite, -2=use default value for archive or non-archive node (whichever is configured)) (default -2) */ - name: 'execution.rpc.max-recreate-state-depth'; + key: 'execution.rpc.max-recreate-state-depth'; type: number; } | { /** allow transactions that aren't EIP-155 replay protected to be submitted over the RPC (default true) */ - name: 'execution.rpc.tx-allow-unprotected'; + key: 'execution.rpc.tx-allow-unprotected'; type: boolean; } | { /** cap on transaction fee (in ether) that can be sent via the RPC APIs (0 = no cap) (default 1) */ - name: 'execution.rpc.tx-fee-cap'; + key: 'execution.rpc.tx-fee-cap'; type: number; } | { /** secondary transaction forwarding target URL */ - name: 'execution.secondary-forwarding-target'; + key: 'execution.secondary-forwarding-target'; type: string[]; } | { /** act and post to l1 as sequencer */ - name: 'execution.sequencer.enable'; + key: 'execution.sequencer.enable'; type: boolean; } | { /** total time to wait before cancelling connection (default 30s) */ - name: 'execution.sequencer.forwarder.connection-timeout'; + key: 'execution.sequencer.forwarder.connection-timeout'; type: string; } | { /** time until idle connections are closed (default 1m0s) */ - name: 'execution.sequencer.forwarder.idle-connection-timeout'; + key: 'execution.sequencer.forwarder.idle-connection-timeout'; type: string; } | { /** maximum number of idle connections to keep open (default 100) */ - name: 'execution.sequencer.forwarder.max-idle-connections'; + key: 'execution.sequencer.forwarder.max-idle-connections'; type: number; } | { /** the Redis URL to recomend target via */ - name: 'execution.sequencer.forwarder.redis-url'; + key: 'execution.sequencer.forwarder.redis-url'; type: string; } | { /** minimal time between update retries (default 100ms) */ - name: 'execution.sequencer.forwarder.retry-interval'; + key: 'execution.sequencer.forwarder.retry-interval'; type: string; } | { /** forwarding target update interval (default 1s) */ - name: 'execution.sequencer.forwarder.update-interval'; + key: 'execution.sequencer.forwarder.update-interval'; type: string; } | { /** maximum acceptable time difference between the local time and the latest L1 block's timestamp (default 1h0m0s) */ - name: 'execution.sequencer.max-acceptable-timestamp-delta'; + key: 'execution.sequencer.max-acceptable-timestamp-delta'; type: string; } | { /** minimum delay between blocks (sets a maximum speed of block production) (default 250ms) */ - name: 'execution.sequencer.max-block-speed'; + key: 'execution.sequencer.max-block-speed'; type: string; } | { /** maximum gas executed in a revert for the sequencer to reject the transaction instead of posting it (anti-DOS) (default 31000) */ - name: 'execution.sequencer.max-revert-gas-reject'; + key: 'execution.sequencer.max-revert-gas-reject'; type: number; } | { /** maximum transaction size the sequencer will accept (default 95000) */ - name: 'execution.sequencer.max-tx-data-size'; + key: 'execution.sequencer.max-tx-data-size'; type: number; } | { /** size of the tx sender nonce cache (default 1024) */ - name: 'execution.sequencer.nonce-cache-size'; + key: 'execution.sequencer.nonce-cache-size'; type: number; } | { /** maximum amount of time to wait for a predecessor before rejecting a tx with nonce too high (default 1s) */ - name: 'execution.sequencer.nonce-failure-cache-expiry'; + key: 'execution.sequencer.nonce-failure-cache-expiry'; type: string; } | { /** number of transactions with too high of a nonce to keep in memory while waiting for their predecessor (default 1024) */ - name: 'execution.sequencer.nonce-failure-cache-size'; + key: 'execution.sequencer.nonce-failure-cache-size'; type: number; } | { /** size of the pending tx queue (default 1024) */ - name: 'execution.sequencer.queue-size'; + key: 'execution.sequencer.queue-size'; type: number; } | { /** maximum amount of time transaction can wait in queue (default 12s) */ - name: 'execution.sequencer.queue-timeout'; + key: 'execution.sequencer.queue-timeout'; type: string; } | { /** comma separated whitelist of authorized senders (if empty, everyone is allowed) */ - name: 'execution.sequencer.sender-whitelist'; + key: 'execution.sequencer.sender-whitelist'; type: string; } | { /** retain the ability to lookup transactions by hash for the past N blocks (0 = all blocks) (default 126230400) */ - name: 'execution.tx-lookup-limit'; + key: 'execution.tx-lookup-limit'; type: number; } | { /** how long ago should the storage conditions from eth_SendRawTransactionConditional be true, 0 = don't check old state (default 2) */ - name: 'execution.tx-pre-checker.required-state-age'; + key: 'execution.tx-pre-checker.required-state-age'; type: number; } | { /** maximum number of blocks to look back while looking for the seconds old state, 0 = don't limit the search (default 4) */ - name: 'execution.tx-pre-checker.required-state-max-blocks'; + key: 'execution.tx-pre-checker.required-state-max-blocks'; type: number; } | { /** how strict to be when checking txs before forwarding them. 0 = accept anything, 10 = should never reject anything that'd succeed, 20 = likely won't reject anything that'd succeed, 30 = full validation which may reject txs that would succeed */ - name: 'execution.tx-pre-checker.strictness'; + key: 'execution.tx-pre-checker.strictness'; type: number; } | { /** size of intermediate log records buffer (default 512) */ - name: 'file-logging.buf-size'; + key: 'file-logging.buf-size'; type: number; } | { /** enable compression of old log files (default true) */ - name: 'file-logging.compress'; + key: 'file-logging.compress'; type: boolean; } | { /** enable logging to file (default true) */ - name: 'file-logging.enable'; + key: 'file-logging.enable'; type: boolean; } | { /** path to log file (default "nitro.log") */ - name: 'file-logging.file'; + key: 'file-logging.file'; type: string; } | { /** if true: local time will be used in old log filename timestamps */ - name: 'file-logging.local-time'; + key: 'file-logging.local-time'; type: boolean; } | { /** maximum number of days to retain old log files based on the timestamp encoded in their filename (0 = no limit) */ - name: 'file-logging.max-age'; + key: 'file-logging.max-age'; type: number; } | { /** maximum number of old log files to retain (0 = no limit) (default 20) */ - name: 'file-logging.max-backups'; + key: 'file-logging.max-backups'; type: number; } | { /** log file size in Mb that will trigger log file rotation (0 = trigger disabled) (default 5) */ - name: 'file-logging.max-size'; + key: 'file-logging.max-size'; type: number; } | { /** Comma separated list of domains from which to accept cross origin requests (browser enforced) */ - name: 'graphql.corsdomain'; + key: 'graphql.corsdomain'; type: string[]; } | { /** Enable graphql endpoint on the rpc endpoint */ - name: 'graphql.enable'; + key: 'graphql.enable'; type: boolean; } | { /** Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard (default [localhost]) */ - name: 'graphql.vhosts'; + key: 'graphql.vhosts'; type: string[]; } | { /** HTTP-RPC server listening interface */ - name: 'http.addr'; + key: 'http.addr'; type: string; } | { /** APIs offered over the HTTP-RPC interface (default [net,web3,eth,arb]) */ - name: 'http.api'; + key: 'http.api'; type: string[]; } | { /** Comma separated list of domains from which to accept cross origin requests (browser enforced) */ - name: 'http.corsdomain'; + key: 'http.corsdomain'; type: string[]; } | { /** HTTP-RPC server listening port (default 8547) */ - name: 'http.port'; + key: 'http.port'; type: number; } | { /** HTTP path path prefix on which JSON-RPC is served. Use '/' to serve on all paths */ - name: 'http.rpcprefix'; + key: 'http.rpcprefix'; type: string; } | { /** the maximum amount of time to wait for the next request when keep-alives are enabled (http.Server.IdleTimeout) (default 2m0s) */ - name: 'http.server-timeouts.idle-timeout'; + key: 'http.server-timeouts.idle-timeout'; type: string; } | { /** the amount of time allowed to read the request headers (http.Server.ReadHeaderTimeout) (default 30s) */ - name: 'http.server-timeouts.read-header-timeout'; + key: 'http.server-timeouts.read-header-timeout'; type: string; } | { /** the maximum duration for reading the entire request (http.Server.ReadTimeout) (default 30s) */ - name: 'http.server-timeouts.read-timeout'; + key: 'http.server-timeouts.read-timeout'; type: string; } | { /** the maximum duration before timing out writes of the response (http.Server.WriteTimeout) (default 30s) */ - name: 'http.server-timeouts.write-timeout'; + key: 'http.server-timeouts.write-timeout'; type: string; } | { /** Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard (default [localhost]) */ - name: 'http.vhosts'; + key: 'http.vhosts'; type: string[]; } | { /** during init - sync database every X accounts. Lower value for low-memory systems. 0 disables. (default 100000) */ - name: 'init.accounts-per-sync'; + key: 'init.accounts-per-sync'; type: number; } | { /** init with dev data (1 account with balance) instead of file import */ - name: 'init.dev-init'; + key: 'init.dev-init'; type: boolean; } | { /** Address of dev-account. Leave empty to use the dev-wallet. */ - name: 'init.dev-init-address'; + key: 'init.dev-init-address'; type: string; } | { /** Number of preinit blocks. Must exist in ancient database. */ - name: 'init.dev-init-blocknum'; + key: 'init.dev-init-blocknum'; type: number; } | { /** path to save temp downloaded file (default "/tmp/") */ - name: 'init.download-path'; + key: 'init.download-path'; type: string; } | { /** how long to wait between polling attempts (default 1m0s) */ - name: 'init.download-poll'; + key: 'init.download-poll'; type: string; } | { /** init with empty state */ - name: 'init.empty'; + key: 'init.empty'; type: boolean; } | { /** if true: in case database exists init code will be reexecuted and genesis block compared to database */ - name: 'init.force'; + key: 'init.force'; type: boolean; } | { /** path for json data to import */ - name: 'init.import-file'; + key: 'init.import-file'; type: string; } | { /** pruning for a given use: "full" for full nodes serving RPC requests, or "validator" for validators */ - name: 'init.prune'; + key: 'init.prune'; type: string; } | { /** the amount of memory in megabytes to use for the pruning bloom filter (higher values prune better) (default 2048) */ - name: 'init.prune-bloom-size'; + key: 'init.prune-bloom-size'; type: number; } | { /** block number to start recreating missing states from (0 = disabled) */ - name: 'init.recreate-missing-state-from'; + key: 'init.recreate-missing-state-from'; type: number; } | { /** forces a reset to an old message height. Also set max-reorg-resequence-depth=0 to force re-reading messages (default -1) */ - name: 'init.reset-to-message'; + key: 'init.reset-to-message'; type: number; } | { /** quit after init is done */ - name: 'init.then-quit'; + key: 'init.then-quit'; type: boolean; } | { /** url to download initializtion data - will poll if download fails */ - name: 'init.url'; + key: 'init.url'; type: string; } | { /** Requested location to place the IPC endpoint. An empty path disables IPC. */ - name: 'ipc.path'; + key: 'ipc.path'; type: string; } | { /** log level (default 3) */ - name: 'log-level'; + key: 'log-level'; type: number; } | { /** log type (plaintext or json) (default "plaintext") */ - name: 'log-type'; + key: 'log-type'; type: string; } | { /** enable metrics */ - name: 'metrics'; + key: 'metrics'; type: boolean; } | { /** metrics server address (default "127.0.0.1") */ - name: 'metrics-server.addr'; + key: 'metrics-server.addr'; type: string; } | { /** metrics server port (default 6070) */ - name: 'metrics-server.port'; + key: 'metrics-server.port'; type: number; } | { /** metrics server update interval (default 3s) */ - name: 'metrics-server.update-interval'; + key: 'metrics-server.update-interval'; type: string; } | { /** batch compression level (default 11) */ - name: 'node.batch-poster.compression-level'; + key: 'node.batch-poster.compression-level'; type: number; } | { /** In AnyTrust mode, the period which DASes are requested to retain the stored batches. (default 360h0m0s) */ - name: 'node.batch-poster.das-retention-period'; + key: 'node.batch-poster.das-retention-period'; type: string; } | { /** if true, don't put transactions in the mempool that spend a total greater than the batch poster's balance (default true) */ - name: 'node.batch-poster.data-poster.allocate-mempool-balance'; + key: 'node.batch-poster.data-poster.allocate-mempool-balance'; type: boolean; } | { /** clear database storage */ - name: 'node.batch-poster.data-poster.dangerous.clear-dbstorage'; + key: 'node.batch-poster.data-poster.dangerous.clear-dbstorage'; type: boolean; } | { /** unit to measure the time elapsed since creation of transaction used for maximum fee cap calculation (default 10m0s) */ - name: 'node.batch-poster.data-poster.elapsed-time-base'; + key: 'node.batch-poster.data-poster.elapsed-time-base'; type: string; } | { /** weight given to the units of time elapsed used for maximum fee cap calculation (default 10) */ - name: 'node.batch-poster.data-poster.elapsed-time-importance'; + key: 'node.batch-poster.data-poster.elapsed-time-importance'; type: number; } | { /** external signer address */ - name: 'node.batch-poster.data-poster.external-signer.address'; + key: 'node.batch-poster.data-poster.external-signer.address'; type: string; } | { /** rpc client cert */ - name: 'node.batch-poster.data-poster.external-signer.client-cert'; + key: 'node.batch-poster.data-poster.external-signer.client-cert'; type: string; } | { /** rpc client private key */ - name: 'node.batch-poster.data-poster.external-signer.client-private-key'; + key: 'node.batch-poster.data-poster.external-signer.client-private-key'; type: string; } | { /** external signer method (default "eth_signTransaction") */ - name: 'node.batch-poster.data-poster.external-signer.method'; + key: 'node.batch-poster.data-poster.external-signer.method'; type: string; } | { /** external signer root CA */ - name: 'node.batch-poster.data-poster.external-signer.root-ca'; + key: 'node.batch-poster.data-poster.external-signer.root-ca'; type: string; } | { /** external signer url */ - name: 'node.batch-poster.data-poster.external-signer.url'; + key: 'node.batch-poster.data-poster.external-signer.url'; type: string; } | { /** encodes items in a legacy way (as it was before dropping generics) */ - name: 'node.batch-poster.data-poster.legacy-storage-encoding'; + key: 'node.batch-poster.data-poster.legacy-storage-encoding'; type: boolean; } | { /** mathematical formula to calculate maximum fee cap gwei the result of which would be float64. This expression is expected to be evaluated please refer https://github.com/Knetic/govaluate/blob/master/MANUAL.md to find all available mathematical operators. Currently available variables to construct the formula are BacklogOfBatches, UrgencyGWei, ElapsedTime, ElapsedTimeBase, ElapsedTimeImportance, and TargetPriceGWei (default "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei") */ - name: 'node.batch-poster.data-poster.max-fee-cap-formula'; + key: 'node.batch-poster.data-poster.max-fee-cap-formula'; type: string; } | { /** the maximum number of transactions to have queued in the mempool at once (0 = unlimited) (default 20) */ - name: 'node.batch-poster.data-poster.max-mempool-transactions'; + key: 'node.batch-poster.data-poster.max-mempool-transactions'; type: number; } | { /** the maximum number of unconfirmed transactions to track at once (0 = unlimited) */ - name: 'node.batch-poster.data-poster.max-queued-transactions'; + key: 'node.batch-poster.data-poster.max-queued-transactions'; type: number; } | { /** the maximum tip cap to post transactions at (default 5) */ - name: 'node.batch-poster.data-poster.max-tip-cap-gwei'; + key: 'node.batch-poster.data-poster.max-tip-cap-gwei'; type: number; } | { /** the minimum fee cap to post transactions at */ - name: 'node.batch-poster.data-poster.min-fee-cap-gwei'; + key: 'node.batch-poster.data-poster.min-fee-cap-gwei'; type: number; } | { /** the minimum tip cap to post transactions at (default 0.05) */ - name: 'node.batch-poster.data-poster.min-tip-cap-gwei'; + key: 'node.batch-poster.data-poster.min-tip-cap-gwei'; type: number; } | { /** the maximum probable reorg depth, used to determine when a transaction will no longer likely need replaced-by-fee (default 1) */ - name: 'node.batch-poster.data-poster.nonce-rbf-soft-confs'; + key: 'node.batch-poster.data-poster.nonce-rbf-soft-confs'; type: number; } | { /** disable message signature verification */ - name: 'node.batch-poster.data-poster.redis-signer.dangerous.disable-signature-verification'; + key: 'node.batch-poster.data-poster.redis-signer.dangerous.disable-signature-verification'; type: boolean; } | { /** a fallback key used for message verification */ - name: 'node.batch-poster.data-poster.redis-signer.fallback-verification-key'; + key: 'node.batch-poster.data-poster.redis-signer.fallback-verification-key'; type: string; } | { /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ - name: 'node.batch-poster.data-poster.redis-signer.signing-key'; + key: 'node.batch-poster.data-poster.redis-signer.signing-key'; type: string; } | { /** comma-separated list of durations since first posting to attempt a replace-by-fee (default "5m,10m,20m,30m,1h,2h,4h,6h,8h,12h,16h,18h,20h,22h") */ - name: 'node.batch-poster.data-poster.replacement-times'; + key: 'node.batch-poster.data-poster.replacement-times'; type: string; } | { /** the target price to use for maximum fee cap calculation (default 60) */ - name: 'node.batch-poster.data-poster.target-price-gwei'; + key: 'node.batch-poster.data-poster.target-price-gwei'; type: number; } | { /** the urgency to use for maximum fee cap calculation (default 2) */ - name: 'node.batch-poster.data-poster.urgency-gwei'; + key: 'node.batch-poster.data-poster.urgency-gwei'; type: number; } | { /** uses database storage when enabled (default true) */ - name: 'node.batch-poster.data-poster.use-db-storage'; + key: 'node.batch-poster.data-poster.use-db-storage'; type: boolean; } | { /** uses noop storage, it doesn't store anything */ - name: 'node.batch-poster.data-poster.use-noop-storage'; + key: 'node.batch-poster.data-poster.use-noop-storage'; type: boolean; } | { /** only treat a transaction as confirmed after L1 finality has been achieved (recommended) (default true) */ - name: 'node.batch-poster.data-poster.wait-for-l1-finality'; + key: 'node.batch-poster.data-poster.wait-for-l1-finality'; type: boolean; } | { /** If unable to batch to DAS, disable fallback storing data on chain */ - name: 'node.batch-poster.disable-das-fallback-store-data-on-chain'; + key: 'node.batch-poster.disable-das-fallback-store-data-on-chain'; type: boolean; } | { /** enable posting batches to l1 */ - name: 'node.batch-poster.enable'; + key: 'node.batch-poster.enable'; type: boolean; } | { /** how long to delay after error posting batch (default 10s) */ - name: 'node.batch-poster.error-delay'; + key: 'node.batch-poster.error-delay'; type: string; } | { /** use this much more gas than estimation says is necessary to post batches (default 50000) */ - name: 'node.batch-poster.extra-batch-gas'; + key: 'node.batch-poster.extra-batch-gas'; type: number; } | { /** The gas refunder contract address (optional) */ - name: 'node.batch-poster.gas-refunder-address'; + key: 'node.batch-poster.gas-refunder-address'; type: string; } | { /** if the parent chain supports 4844 blobs and ignore-blob-price is true, post 4844 blobs even if it's not price efficient */ - name: 'node.batch-poster.ignore-blob-price'; + key: 'node.batch-poster.ignore-blob-price'; type: boolean; } | { /** only post messages to batches when they're within the max future block/timestamp as of this L1 block tag ("safe", "finalized", "latest", or "ignore" to ignore this check) */ - name: 'node.batch-poster.l1-block-bound'; + key: 'node.batch-poster.l1-block-bound'; type: string; } | { /** post batches even if not within the layer 1 future bounds if we're within this margin of the max delay (default 1h0m0s) */ - name: 'node.batch-poster.l1-block-bound-bypass'; + key: 'node.batch-poster.l1-block-bound-bypass'; type: string; } | { /** maximum 4844 blob enabled batch size (default 779288) */ - name: 'node.batch-poster.max-4844-batch-size'; + key: 'node.batch-poster.max-4844-batch-size'; type: number; } | { /** maximum batch posting delay (default 1h0m0s) */ - name: 'node.batch-poster.max-delay'; + key: 'node.batch-poster.max-delay'; type: string; } | { /** maximum batch size (default 100000) */ - name: 'node.batch-poster.max-size'; + key: 'node.batch-poster.max-size'; type: number; } | { /** account to use (default is first account in keystore) */ - name: 'node.batch-poster.parent-chain-wallet.account'; + key: 'node.batch-poster.parent-chain-wallet.account'; type: string; } | { /** if true, creates new key then exits */ - name: 'node.batch-poster.parent-chain-wallet.only-create-key'; + key: 'node.batch-poster.parent-chain-wallet.only-create-key'; type: boolean; } | { /** wallet passphrase (default "PASSWORD_NOT_SET") */ - name: 'node.batch-poster.parent-chain-wallet.password'; + key: 'node.batch-poster.parent-chain-wallet.password'; type: string; } | { /** pathname for wallet (default "batch-poster-wallet") */ - name: 'node.batch-poster.parent-chain-wallet.pathname'; + key: 'node.batch-poster.parent-chain-wallet.pathname'; type: string; } | { /** private key for wallet */ - name: 'node.batch-poster.parent-chain-wallet.private-key'; + key: 'node.batch-poster.parent-chain-wallet.private-key'; type: string; } | { /** how long to wait after no batches are ready to be posted before checking again (default 10s) */ - name: 'node.batch-poster.poll-interval'; + key: 'node.batch-poster.poll-interval'; type: string; } | { /** if the parent chain supports 4844 blobs and they're well priced, post EIP-4844 blobs */ - name: 'node.batch-poster.post-4844-blobs'; + key: 'node.batch-poster.post-4844-blobs'; type: boolean; } | { /** should node always try grabing lock in background */ - name: 'node.batch-poster.redis-lock.background-lock'; + key: 'node.batch-poster.redis-lock.background-lock'; type: boolean; } | { /** if false, always treat this as locked and don't write the lock to redis (default true) */ - name: 'node.batch-poster.redis-lock.enable'; + key: 'node.batch-poster.redis-lock.enable'; type: boolean; } | { /** key for lock */ - name: 'node.batch-poster.redis-lock.key'; + key: 'node.batch-poster.redis-lock.key'; type: string; } | { /** how long lock is held (default 1m0s) */ - name: 'node.batch-poster.redis-lock.lockout-duration'; + key: 'node.batch-poster.redis-lock.lockout-duration'; type: string; } | { /** this node's id prefix when acquiring the lock (optional) */ - name: 'node.batch-poster.redis-lock.my-id'; + key: 'node.batch-poster.redis-lock.my-id'; type: string; } | { /** how long between consecutive calls to redis (default 10s) */ - name: 'node.batch-poster.redis-lock.refresh-duration'; + key: 'node.batch-poster.redis-lock.refresh-duration'; type: string; } | { /** if non-empty, the Redis URL to store queued transactions in */ - name: 'node.batch-poster.redis-url'; + key: 'node.batch-poster.redis-url'; type: string; } | { /** post batches with access lists to reduce gas usage (disabled for L3s) (default true) */ - name: 'node.batch-poster.use-access-lists'; + key: 'node.batch-poster.use-access-lists'; type: boolean; } | { /** wait for the max batch delay, even if the batch is full */ - name: 'node.batch-poster.wait-for-max-delay'; + key: 'node.batch-poster.wait-for-max-delay'; type: boolean; } | { /** current wasm module root ('current' read from chain, 'latest' from machines/latest dir, or provide hash) (default "current") */ - name: 'node.block-validator.current-module-root'; + key: 'node.block-validator.current-module-root'; type: string; } | { /** resets block-by-block validation, starting again at genesis */ - name: 'node.block-validator.dangerous.reset-block-validation'; + key: 'node.block-validator.dangerous.reset-block-validation'; type: boolean; } | { /** enable block-by-block validation */ - name: 'node.block-validator.enable'; + key: 'node.block-validator.enable'; type: boolean; } | { /** failing a validation is treated as a fatal error (default true) */ - name: 'node.block-validator.failure-is-fatal'; + key: 'node.block-validator.failure-is-fatal'; type: boolean; } | { /** prepare entries for up to that many blocks ahead of validation (small footprint) (default 1024) */ - name: 'node.block-validator.forward-blocks'; + key: 'node.block-validator.forward-blocks'; type: number; } | { /** minimum free-memory limit after reaching which the blockvalidator pauses validation. Enabled by default as 1GB, to disable provide empty string (default "default") */ - name: 'node.block-validator.memory-free-limit'; + key: 'node.block-validator.memory-free-limit'; type: string; } | { /** pending upgrade wasm module root to additionally validate (hash, 'latest' or empty) (default "latest") */ - name: 'node.block-validator.pending-upgrade-module-root'; + key: 'node.block-validator.pending-upgrade-module-root'; type: string; } | { /** record that many blocks ahead of validation (larger footprint) (default 24) */ - name: 'node.block-validator.prerecorded-blocks'; + key: 'node.block-validator.prerecorded-blocks'; type: number; } | { /** poll time to check validations (default 1s) */ - name: 'node.block-validator.validation-poll'; + key: 'node.block-validator.validation-poll'; type: string; } | { /** array of validation rpc configs given as a json string. time duration should be supplied in number indicating nanoseconds (default "default") */ - name: 'node.block-validator.validation-server-configs-list'; + key: 'node.block-validator.validation-server-configs-list'; type: string; } | { /** limit size of arguments in log entries (default 2048) */ - name: 'node.block-validator.validation-server.arg-log-limit'; + key: 'node.block-validator.validation-server.arg-log-limit'; type: number; } | { /** how long to wait for initial connection */ - name: 'node.block-validator.validation-server.connection-wait'; + key: 'node.block-validator.validation-server.connection-wait'; type: string; } | { /** path to file with jwtsecret for validation - ignored if url is self or self-auth */ - name: 'node.block-validator.validation-server.jwtsecret'; + key: 'node.block-validator.validation-server.jwtsecret'; type: string; } | { /** number of retries in case of failure(0 mean one attempt) (default 3) */ - name: 'node.block-validator.validation-server.retries'; + key: 'node.block-validator.validation-server.retries'; type: number; } | { /** delay between retries */ - name: 'node.block-validator.validation-server.retry-delay'; + key: 'node.block-validator.validation-server.retry-delay'; type: string; } | { /** Errors matching this regular expression are automatically retried (default "websocket: close.*|dial tcp .*|.*i/o timeout|.*connection reset by peer|.*connection refused") */ - name: 'node.block-validator.validation-server.retry-errors'; + key: 'node.block-validator.validation-server.retry-errors'; type: string; } | { /** per-response timeout (0-disabled) */ - name: 'node.block-validator.validation-server.timeout'; + key: 'node.block-validator.validation-server.timeout'; type: string; } | { /** url of server, use self for loopback websocket, self-auth for loopback with authentication (default "self-auth") */ - name: 'node.block-validator.validation-server.url'; + key: 'node.block-validator.validation-server.url'; type: string; } | { /** DANGEROUS! disables the EIP-4844 blob reader, which is necessary to read batches */ - name: 'node.dangerous.disable-blob-reader'; + key: 'node.dangerous.disable-blob-reader'; type: boolean; } | { /** DANGEROUS! disables listening to L1. To be used in test nodes only */ - name: 'node.dangerous.no-l1-listener'; + key: 'node.dangerous.no-l1-listener'; type: boolean; } | { /** DANGEROUS! allows sequencing without sequencer-coordinator */ - name: 'node.dangerous.no-sequencer-coordinator'; + key: 'node.dangerous.no-sequencer-coordinator'; type: boolean; } | { /** enable Anytrust Data Availability mode */ - name: 'node.data-availability.enable'; + key: 'node.data-availability.enable'; type: boolean; } | { /** enable storage/retrieval of sequencer batch data from IPFS */ - name: 'node.data-availability.ipfs-storage.enable'; + key: 'node.data-availability.ipfs-storage.enable'; type: boolean; } | { /** list of IPFS peers to connect to, eg /ip4/1.2.3.4/tcp/12345/p2p/abc...xyz */ - name: 'node.data-availability.ipfs-storage.peers'; + key: 'node.data-availability.ipfs-storage.peers'; type: string[]; } | { /** pin sequencer batch data in IPFS (default true) */ - name: 'node.data-availability.ipfs-storage.pin-after-get'; + key: 'node.data-availability.ipfs-storage.pin-after-get'; type: boolean; } | { /** percent of sequencer batch data to pin, as a floating point number in the range 0.0 to 100.0 (default 100) */ - name: 'node.data-availability.ipfs-storage.pin-percentage'; + key: 'node.data-availability.ipfs-storage.pin-percentage'; type: number; } | { /** comma separated list of IPFS profiles to use, see https://docs.ipfs.tech/how-to/default-profile */ - name: 'node.data-availability.ipfs-storage.profiles'; + key: 'node.data-availability.ipfs-storage.profiles'; type: string; } | { /** timeout for IPFS reads, since by default it will wait forever. Treat timeout as not found (default 1m0s) */ - name: 'node.data-availability.ipfs-storage.read-timeout'; + key: 'node.data-availability.ipfs-storage.read-timeout'; type: string; } | { /** directory to use to store the local IPFS repo */ - name: 'node.data-availability.ipfs-storage.repo-dir'; + key: 'node.data-availability.ipfs-storage.repo-dir'; type: string; } | { /** whether the Data Availability Service should fail immediately on errors (not recommended) */ - name: 'node.data-availability.panic-on-error'; + key: 'node.data-availability.panic-on-error'; type: boolean; } | { /** parent chain RPC connection attempts (spaced out at least 1 second per attempt, 0 to retry infinitely), only used in standalone daserver; when running as part of a node that node's parent chain configuration is used (default 15) */ - name: 'node.data-availability.parent-chain-connection-attempts'; + key: 'node.data-availability.parent-chain-connection-attempts'; type: number; } | { /** URL for parent chain node, only used in standalone daserver; when running as part of a node that node's L1 configuration is used */ - name: 'node.data-availability.parent-chain-node-url'; + key: 'node.data-availability.parent-chain-node-url'; type: string; } | { /** Data Availability Service timeout duration for Store requests (default 5s) */ - name: 'node.data-availability.request-timeout'; + key: 'node.data-availability.request-timeout'; type: string; } | { /** enable retrieval of sequencer batch data from a list of remote REST endpoints; if other DAS storage types are enabled, this mode is used as a fallback */ - name: 'node.data-availability.rest-aggregator.enable'; + key: 'node.data-availability.rest-aggregator.enable'; type: boolean; } | { /** number of stats entries (latency and success rate) to keep for each REST endpoint; controls whether strategy is faster or slower to respond to changing conditions (default 20) */ - name: 'node.data-availability.rest-aggregator.max-per-endpoint-stats'; + key: 'node.data-availability.rest-aggregator.max-per-endpoint-stats'; type: number; } | { /** a URL to a list of URLs of REST das endpoints that is checked at startup; additive with the url option */ - name: 'node.data-availability.rest-aggregator.online-url-list'; + key: 'node.data-availability.rest-aggregator.online-url-list'; type: string; } | { /** time interval to periodically fetch url list from online-url-list (default 1h0m0s) */ - name: 'node.data-availability.rest-aggregator.online-url-list-fetch-interval'; + key: 'node.data-availability.rest-aggregator.online-url-list-fetch-interval'; type: string; } | { /** number of consecutive GetByHash calls to the aggregator where each call will cause it to select from REST endpoints in order of best latency and success rate, before switching to explore mode (default 1000) */ - name: 'node.data-availability.rest-aggregator.simple-explore-exploit-strategy.exploit-iterations'; + key: 'node.data-availability.rest-aggregator.simple-explore-exploit-strategy.exploit-iterations'; type: number; } | { /** number of consecutive GetByHash calls to the aggregator where each call will cause it to randomly select from REST endpoints until one returns successfully, before switching to exploit mode (default 20) */ - name: 'node.data-availability.rest-aggregator.simple-explore-exploit-strategy.explore-iterations'; + key: 'node.data-availability.rest-aggregator.simple-explore-exploit-strategy.explore-iterations'; type: number; } | { /** strategy to use to determine order and parallelism of calling REST endpoint URLs; valid options are 'simple-explore-exploit' (default "simple-explore-exploit") */ - name: 'node.data-availability.rest-aggregator.strategy'; + key: 'node.data-availability.rest-aggregator.strategy'; type: string; } | { /** how frequently to update the strategy with endpoint latency and error rate data (default 10s) */ - name: 'node.data-availability.rest-aggregator.strategy-update-interval'; + key: 'node.data-availability.rest-aggregator.strategy-update-interval'; type: string; } | { /** check if the data already exists in this DAS's storage. Must be disabled for fast sync with an IPFS backend (default true) */ - name: 'node.data-availability.rest-aggregator.sync-to-storage.check-already-exists'; + key: 'node.data-availability.rest-aggregator.sync-to-storage.check-already-exists'; type: boolean; } | { /** time to wait if encountered an error before retrying (default 1s) */ - name: 'node.data-availability.rest-aggregator.sync-to-storage.delay-on-error'; + key: 'node.data-availability.rest-aggregator.sync-to-storage.delay-on-error'; type: string; } | { /** eagerly sync batch data to this DAS's storage from the rest endpoints, using L1 as the index of batch data hashes; otherwise only sync lazily */ - name: 'node.data-availability.rest-aggregator.sync-to-storage.eager'; + key: 'node.data-availability.rest-aggregator.sync-to-storage.eager'; type: boolean; } | { /** when eagerly syncing, start indexing forward from this L1 block. Only used if there is no sync state */ - name: 'node.data-availability.rest-aggregator.sync-to-storage.eager-lower-bound-block'; + key: 'node.data-availability.rest-aggregator.sync-to-storage.eager-lower-bound-block'; type: number; } | { /** log only on failures to write when syncing; otherwise treat it as an error (default true) */ - name: 'node.data-availability.rest-aggregator.sync-to-storage.ignore-write-errors'; + key: 'node.data-availability.rest-aggregator.sync-to-storage.ignore-write-errors'; type: boolean; } | { /** when eagerly syncing, max l1 blocks to read per poll (default 100) */ - name: 'node.data-availability.rest-aggregator.sync-to-storage.parent-chain-blocks-per-read'; + key: 'node.data-availability.rest-aggregator.sync-to-storage.parent-chain-blocks-per-read'; type: number; } | { /** period to retain synced data (defaults to forever) (default 2562047h47m16.854775807s) */ - name: 'node.data-availability.rest-aggregator.sync-to-storage.retention-period'; + key: 'node.data-availability.rest-aggregator.sync-to-storage.retention-period'; type: string; } | { /** directory to store the sync state in, ie the block number currently synced up to, so that we don't sync from scratch each time */ - name: 'node.data-availability.rest-aggregator.sync-to-storage.state-dir'; + key: 'node.data-availability.rest-aggregator.sync-to-storage.state-dir'; type: string; } | { /** list of URLs including 'http://' or 'https://' prefixes and port numbers to REST DAS endpoints; additive with the online-url-list option */ - name: 'node.data-availability.rest-aggregator.urls'; + key: 'node.data-availability.rest-aggregator.urls'; type: string[]; } | { /** time to wait until trying the next set of REST endpoints while waiting for a response; the next set of REST endpoints is determined by the strategy selected (default 2s) */ - name: 'node.data-availability.rest-aggregator.wait-before-try-next'; + key: 'node.data-availability.rest-aggregator.wait-before-try-next'; type: string; } | { /** Number of assumed honest backends (H). If there are N backends, K=N+1-H valid responses are required to consider an Store request to be successful. */ - name: 'node.data-availability.rpc-aggregator.assumed-honest'; + key: 'node.data-availability.rpc-aggregator.assumed-honest'; type: number; } | { /** JSON RPC backend configuration */ - name: 'node.data-availability.rpc-aggregator.backends'; + key: 'node.data-availability.rpc-aggregator.backends'; type: string; } | { /** enable storage/retrieval of sequencer batch data from a list of RPC endpoints; this should only be used by the batch poster and not in combination with other DAS storage types */ - name: 'node.data-availability.rpc-aggregator.enable'; + key: 'node.data-availability.rpc-aggregator.enable'; type: boolean; } | { /** parent chain address of SequencerInbox contract */ - name: 'node.data-availability.sequencer-inbox-address'; + key: 'node.data-availability.sequencer-inbox-address'; type: string; } | { /** enable delayed sequencer */ - name: 'node.delayed-sequencer.enable'; + key: 'node.delayed-sequencer.enable'; type: boolean; } | { /** how many blocks in the past L1 block is considered final (ignored when using Merge finality) (default 20) */ - name: 'node.delayed-sequencer.finalize-distance'; + key: 'node.delayed-sequencer.finalize-distance'; type: number; } | { /** whether to wait for full finality before sequencing delayed messages */ - name: 'node.delayed-sequencer.require-full-finality'; + key: 'node.delayed-sequencer.require-full-finality'; type: boolean; } | { /** whether to use The Merge's notion of finality before sequencing delayed messages (default true) */ - name: 'node.delayed-sequencer.use-merge-finality'; + key: 'node.delayed-sequencer.use-merge-finality'; type: boolean; } | { /** enable per message deflate compression support (default true) */ - name: 'node.feed.input.enable-compression'; + key: 'node.feed.input.enable-compression'; type: boolean; } | { /** initial duration to wait before reconnect (default 1s) */ - name: 'node.feed.input.reconnect-initial-backoff'; + key: 'node.feed.input.reconnect-initial-backoff'; type: string; } | { /** maximum duration to wait before reconnect (default 1m4s) */ - name: 'node.feed.input.reconnect-maximum-backoff'; + key: 'node.feed.input.reconnect-maximum-backoff'; type: string; } | { /** require chain id to be present on connect */ - name: 'node.feed.input.require-chain-id'; + key: 'node.feed.input.require-chain-id'; type: boolean; } | { /** require feed version to be present on connect */ - name: 'node.feed.input.require-feed-version'; + key: 'node.feed.input.require-feed-version'; type: boolean; } | { /** list of secondary URLs of sequencer feed source. Would be started in the order they appear in the list when primary feeds fails */ - name: 'node.feed.input.secondary-url'; + key: 'node.feed.input.secondary-url'; type: string[]; } | { /** duration to wait before timing out connection to sequencer feed (default 20s) */ - name: 'node.feed.input.timeout'; + key: 'node.feed.input.timeout'; type: string; } | { /** list of primary URLs of sequencer feed source */ - name: 'node.feed.input.url'; + key: 'node.feed.input.url'; type: string[]; } | { /** accept verified message from sequencer (default true) */ - name: 'node.feed.input.verify.accept-sequencer'; + key: 'node.feed.input.verify.accept-sequencer'; type: boolean; } | { /** a list of allowed addresses */ - name: 'node.feed.input.verify.allowed-addresses'; + key: 'node.feed.input.verify.allowed-addresses'; type: string[]; } | { /** accept empty as valid signature (default true) */ - name: 'node.feed.input.verify.dangerous.accept-missing'; + key: 'node.feed.input.verify.dangerous.accept-missing'; type: boolean; } | { /** address to bind the relay feed output to */ - name: 'node.feed.output.addr'; + key: 'node.feed.output.addr'; type: string; } | { /** the maximum number of messages each segment within the backlog can contain (default 240) */ - name: 'node.feed.output.backlog.segment-limit'; + key: 'node.feed.output.backlog.segment-limit'; type: number; } | { /** delay the first messages sent to each client by this amount */ - name: 'node.feed.output.client-delay'; + key: 'node.feed.output.client-delay'; type: string; } | { /** duration to wait before timing out connections to client (default 15s) */ - name: 'node.feed.output.client-timeout'; + key: 'node.feed.output.client-timeout'; type: string; } | { /** enable broadcaster per-client connection limiting */ - name: 'node.feed.output.connection-limits.enable'; + key: 'node.feed.output.connection-limits.enable'; type: boolean; } | { /** limit clients, as identified by IPv4/v6 address, to this many connections to this relay (default 5) */ - name: 'node.feed.output.connection-limits.per-ip-limit'; + key: 'node.feed.output.connection-limits.per-ip-limit'; type: number; } | { /** limit ipv6 clients, as identified by IPv6 address masked with /48, to this many connections to this relay (default 20) */ - name: 'node.feed.output.connection-limits.per-ipv6-cidr-48-limit'; + key: 'node.feed.output.connection-limits.per-ipv6-cidr-48-limit'; type: number; } | { /** limit ipv6 clients, as identified by IPv6 address masked with /64, to this many connections to this relay (default 10) */ - name: 'node.feed.output.connection-limits.per-ipv6-cidr-64-limit'; + key: 'node.feed.output.connection-limits.per-ipv6-cidr-64-limit'; type: number; } | { /** time to wait after a relay client disconnects before the disconnect is registered with respect to the limit for this client */ - name: 'node.feed.output.connection-limits.reconnect-cooldown-period'; + key: 'node.feed.output.connection-limits.reconnect-cooldown-period'; type: string; } | { /** don't sign feed messages (default true) */ - name: 'node.feed.output.disable-signing'; + key: 'node.feed.output.disable-signing'; type: boolean; } | { /** enable broadcaster */ - name: 'node.feed.output.enable'; + key: 'node.feed.output.enable'; type: boolean; } | { /** enable per message deflate compression support */ - name: 'node.feed.output.enable-compression'; + key: 'node.feed.output.enable-compression'; type: boolean; } | { /** duration to wait before timing out HTTP to WS upgrade (default 1s) */ - name: 'node.feed.output.handshake-timeout'; + key: 'node.feed.output.handshake-timeout'; type: string; } | { /** only supply catchup buffer if requested sequence number is reasonable */ - name: 'node.feed.output.limit-catchup'; + key: 'node.feed.output.limit-catchup'; type: boolean; } | { /** log every client connect */ - name: 'node.feed.output.log-connect'; + key: 'node.feed.output.log-connect'; type: boolean; } | { /** log every client disconnect */ - name: 'node.feed.output.log-disconnect'; + key: 'node.feed.output.log-disconnect'; type: boolean; } | { /** the maximum size of the catchup buffer (-1 means unlimited) (default -1) */ - name: 'node.feed.output.max-catchup'; + key: 'node.feed.output.max-catchup'; type: number; } | { /** maximum number of messages allowed to accumulate before client is disconnected (default 4096) */ - name: 'node.feed.output.max-send-queue'; + key: 'node.feed.output.max-send-queue'; type: number; } | { /** duration for ping interval (default 5s) */ - name: 'node.feed.output.ping'; + key: 'node.feed.output.ping'; type: string; } | { /** port to bind the relay feed output to (default "9642") */ - name: 'node.feed.output.port'; + key: 'node.feed.output.port'; type: string; } | { /** queue size for HTTP to WS upgrade (default 100) */ - name: 'node.feed.output.queue'; + key: 'node.feed.output.queue'; type: number; } | { /** duration to wait before timing out reading data (i.e. pings) from clients (default 1s) */ - name: 'node.feed.output.read-timeout'; + key: 'node.feed.output.read-timeout'; type: string; } | { /** require clients to use compression */ - name: 'node.feed.output.require-compression'; + key: 'node.feed.output.require-compression'; type: boolean; } | { /** don't connect if client version not present */ - name: 'node.feed.output.require-version'; + key: 'node.feed.output.require-version'; type: boolean; } | { /** sign broadcast messages */ - name: 'node.feed.output.signed'; + key: 'node.feed.output.signed'; type: boolean; } | { /** number of threads to reserve for HTTP to WS upgrade (default 100) */ - name: 'node.feed.output.workers'; + key: 'node.feed.output.workers'; type: number; } | { /** duration to wait before timing out writing data to clients (default 2s) */ - name: 'node.feed.output.write-timeout'; + key: 'node.feed.output.write-timeout'; type: string; } | { /** the maximum time to wait between inbox checks (if not enough new blocks are found) (default 1m0s) */ - name: 'node.inbox-reader.check-delay'; + key: 'node.inbox-reader.check-delay'; type: string; } | { /** the default number of blocks to read at once (will vary based on traffic by default) (default 100) */ - name: 'node.inbox-reader.default-blocks-to-read'; + key: 'node.inbox-reader.default-blocks-to-read'; type: number; } | { /** number of latest blocks to ignore to reduce reorgs */ - name: 'node.inbox-reader.delay-blocks'; + key: 'node.inbox-reader.delay-blocks'; type: number; } | { /** erase future transactions in addition to overwriting existing ones on reorg */ - name: 'node.inbox-reader.hard-reorg'; + key: 'node.inbox-reader.hard-reorg'; type: boolean; } | { /** if adjust-blocks-to-read is enabled, the maximum number of blocks to read at once (default 2000) */ - name: 'node.inbox-reader.max-blocks-to-read'; + key: 'node.inbox-reader.max-blocks-to-read'; type: number; } | { /** the minimum number of blocks to read at once (when caught up lowers load on L1) (default 1) */ - name: 'node.inbox-reader.min-blocks-to-read'; + key: 'node.inbox-reader.min-blocks-to-read'; type: number; } | { /** mode to only read latest or safe or finalized L1 blocks. Enabling safe or finalized disables feed input and output. Defaults to latest. Takes string input, valid strings- latest, safe, finalized (default "latest") */ - name: 'node.inbox-reader.read-mode'; + key: 'node.inbox-reader.read-mode'; type: string; } | { /** if adjust-blocks-to-read is enabled, the target number of messages to read at once (default 500) */ - name: 'node.inbox-reader.target-messages-read'; + key: 'node.inbox-reader.target-messages-read'; type: number; } | { /** should node always try grabing lock in background */ - name: 'node.maintenance.lock.background-lock'; + key: 'node.maintenance.lock.background-lock'; type: boolean; } | { /** if false, always treat this as locked and don't write the lock to redis (default true) */ - name: 'node.maintenance.lock.enable'; + key: 'node.maintenance.lock.enable'; type: boolean; } | { /** key for lock */ - name: 'node.maintenance.lock.key'; + key: 'node.maintenance.lock.key'; type: string; } | { /** how long lock is held (default 1m0s) */ - name: 'node.maintenance.lock.lockout-duration'; + key: 'node.maintenance.lock.lockout-duration'; type: string; } | { /** this node's id prefix when acquiring the lock (optional) */ - name: 'node.maintenance.lock.my-id'; + key: 'node.maintenance.lock.my-id'; type: string; } | { /** how long between consecutive calls to redis (default 10s) */ - name: 'node.maintenance.lock.refresh-duration'; + key: 'node.maintenance.lock.refresh-duration'; type: string; } | { /** UTC 24-hour time of day to run maintenance (currently only db compaction) at (e.g. 15:00) */ - name: 'node.maintenance.time-of-day'; + key: 'node.maintenance.time-of-day'; type: string; } | { /** enable message pruning (default true) */ - name: 'node.message-pruner.enable'; + key: 'node.message-pruner.enable'; type: boolean; } | { /** min number of batches not pruned (default 2) */ - name: 'node.message-pruner.min-batches-left'; + key: 'node.message-pruner.min-batches-left'; type: number; } | { /** interval for running message pruner (default 1m0s) */ - name: 'node.message-pruner.prune-interval'; + key: 'node.message-pruner.prune-interval'; type: string; } | { /** Dangerous! only meant to be used by system tests */ - name: 'node.parent-chain-reader.dangerous.wait-for-tx-approval-safe-poll'; + key: 'node.parent-chain-reader.dangerous.wait-for-tx-approval-safe-poll'; type: string; } | { /** enable reader connection (default true) */ - name: 'node.parent-chain-reader.enable'; + key: 'node.parent-chain-reader.enable'; type: boolean; } | { /** warns if the latest l1 block is at least this old (default 5m0s) */ - name: 'node.parent-chain-reader.old-header-timeout'; + key: 'node.parent-chain-reader.old-header-timeout'; type: string; } | { /** interval when polling endpoint (default 15s) */ - name: 'node.parent-chain-reader.poll-interval'; + key: 'node.parent-chain-reader.poll-interval'; type: string; } | { /** do not attempt to subscribe to header events */ - name: 'node.parent-chain-reader.poll-only'; + key: 'node.parent-chain-reader.poll-only'; type: boolean; } | { /** interval for subscribe error (default 5m0s) */ - name: 'node.parent-chain-reader.subscribe-err-interval'; + key: 'node.parent-chain-reader.subscribe-err-interval'; type: string; } | { /** timeout when waiting for a transaction (default 5m0s) */ - name: 'node.parent-chain-reader.tx-timeout'; + key: 'node.parent-chain-reader.tx-timeout'; type: string; } | { /** use l1 data about finalized/safe blocks (default true) */ - name: 'node.parent-chain-reader.use-finality-data'; + key: 'node.parent-chain-reader.use-finality-data'; type: boolean; } | { /** if non-empty, launch an HTTP service binding to this address that returns status code 200 when chosen and 503 otherwise */ - name: 'node.seq-coordinator.chosen-healthcheck-addr'; + key: 'node.seq-coordinator.chosen-healthcheck-addr'; type: string; } | { /** enable sequence coordinator */ - name: 'node.seq-coordinator.enable'; + key: 'node.seq-coordinator.enable'; type: boolean; } | { /** the maximum amount of time to spend waiting for another sequencer to accept the lockout when handing it off on shutdown or db compaction (default 30s) */ - name: 'node.seq-coordinator.handoff-timeout'; + key: 'node.seq-coordinator.handoff-timeout'; type: string; } | { /** (default 1m0s) */ - name: 'node.seq-coordinator.lockout-duration'; + key: 'node.seq-coordinator.lockout-duration'; type: string; } | { /** (default 30s) */ - name: 'node.seq-coordinator.lockout-spare'; + key: 'node.seq-coordinator.lockout-spare'; type: string; } | { /** will only be marked as wanting the lockout if not too far behind (default 2000) */ - name: 'node.seq-coordinator.msg-per-poll'; + key: 'node.seq-coordinator.msg-per-poll'; type: number; } | { /** url for this sequencer if it is the chosen (default "") */ - name: 'node.seq-coordinator.my-url'; + key: 'node.seq-coordinator.my-url'; type: string; } | { /** the Redis URL to coordinate via */ - name: 'node.seq-coordinator.redis-url'; + key: 'node.seq-coordinator.redis-url'; type: string; } | { /** the number of times to retry releasing the wants lockout and chosen one status on shutdown (default 4) */ - name: 'node.seq-coordinator.release-retries'; + key: 'node.seq-coordinator.release-retries'; type: number; } | { /** (default 50ms) */ - name: 'node.seq-coordinator.retry-interval'; + key: 'node.seq-coordinator.retry-interval'; type: string; } | { /** if non-zero will add delay after transferring control (default 5s) */ - name: 'node.seq-coordinator.safe-shutdown-delay'; + key: 'node.seq-coordinator.safe-shutdown-delay'; type: string; } | { /** (default 24h0m0s) */ - name: 'node.seq-coordinator.seq-num-duration'; + key: 'node.seq-coordinator.seq-num-duration'; type: string; } | { /** accept verified message from sequencer (default true) */ - name: 'node.seq-coordinator.signer.ecdsa.accept-sequencer'; + key: 'node.seq-coordinator.signer.ecdsa.accept-sequencer'; type: boolean; } | { /** a list of allowed addresses */ - name: 'node.seq-coordinator.signer.ecdsa.allowed-addresses'; + key: 'node.seq-coordinator.signer.ecdsa.allowed-addresses'; type: string[]; } | { /** accept empty as valid signature (default true) */ - name: 'node.seq-coordinator.signer.ecdsa.dangerous.accept-missing'; + key: 'node.seq-coordinator.signer.ecdsa.dangerous.accept-missing'; type: boolean; } | { /** if to fall back to symmetric hmac */ - name: 'node.seq-coordinator.signer.symmetric-fallback'; + key: 'node.seq-coordinator.signer.symmetric-fallback'; type: boolean; } | { /** if to sign with symmetric hmac */ - name: 'node.seq-coordinator.signer.symmetric-sign'; + key: 'node.seq-coordinator.signer.symmetric-sign'; type: boolean; } | { /** disable message signature verification */ - name: 'node.seq-coordinator.signer.symmetric.dangerous.disable-signature-verification'; + key: 'node.seq-coordinator.signer.symmetric.dangerous.disable-signature-verification'; type: boolean; } | { /** a fallback key used for message verification */ - name: 'node.seq-coordinator.signer.symmetric.fallback-verification-key'; + key: 'node.seq-coordinator.signer.symmetric.fallback-verification-key'; type: string; } | { /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ - name: 'node.seq-coordinator.signer.symmetric.signing-key'; + key: 'node.seq-coordinator.signer.symmetric.signing-key'; type: string; } | { /** (default 250ms) */ - name: 'node.seq-coordinator.update-interval'; + key: 'node.seq-coordinator.update-interval'; type: string; } | { /** enable sequencer */ - name: 'node.sequencer'; + key: 'node.sequencer'; type: boolean; } | { /** confirmation blocks (default 12) */ - name: 'node.staker.confirmation-blocks'; + key: 'node.staker.confirmation-blocks'; type: number; } | { /** validator smart contract wallet public address */ - name: 'node.staker.contract-wallet-address'; + key: 'node.staker.contract-wallet-address'; type: string; } | { /** DANGEROUS! make assertions even when the wasm module root is wrong */ - name: 'node.staker.dangerous.ignore-rollup-wasm-module-root'; + key: 'node.staker.dangerous.ignore-rollup-wasm-module-root'; type: boolean; } | { /** DANGEROUS! allows running an L1 validator without a block validator */ - name: 'node.staker.dangerous.without-block-validator'; + key: 'node.staker.dangerous.without-block-validator'; type: boolean; } | { /** if true, don't put transactions in the mempool that spend a total greater than the batch poster's balance (default true) */ - name: 'node.staker.data-poster.allocate-mempool-balance'; + key: 'node.staker.data-poster.allocate-mempool-balance'; type: boolean; } | { /** clear database storage */ - name: 'node.staker.data-poster.dangerous.clear-dbstorage'; + key: 'node.staker.data-poster.dangerous.clear-dbstorage'; type: boolean; } | { /** unit to measure the time elapsed since creation of transaction used for maximum fee cap calculation (default 10m0s) */ - name: 'node.staker.data-poster.elapsed-time-base'; + key: 'node.staker.data-poster.elapsed-time-base'; type: string; } | { /** weight given to the units of time elapsed used for maximum fee cap calculation (default 10) */ - name: 'node.staker.data-poster.elapsed-time-importance'; + key: 'node.staker.data-poster.elapsed-time-importance'; type: number; } | { /** external signer address */ - name: 'node.staker.data-poster.external-signer.address'; + key: 'node.staker.data-poster.external-signer.address'; type: string; } | { /** rpc client cert */ - name: 'node.staker.data-poster.external-signer.client-cert'; + key: 'node.staker.data-poster.external-signer.client-cert'; type: string; } | { /** rpc client private key */ - name: 'node.staker.data-poster.external-signer.client-private-key'; + key: 'node.staker.data-poster.external-signer.client-private-key'; type: string; } | { /** external signer method (default "eth_signTransaction") */ - name: 'node.staker.data-poster.external-signer.method'; + key: 'node.staker.data-poster.external-signer.method'; type: string; } | { /** external signer root CA */ - name: 'node.staker.data-poster.external-signer.root-ca'; + key: 'node.staker.data-poster.external-signer.root-ca'; type: string; } | { /** external signer url */ - name: 'node.staker.data-poster.external-signer.url'; + key: 'node.staker.data-poster.external-signer.url'; type: string; } | { /** encodes items in a legacy way (as it was before dropping generics) */ - name: 'node.staker.data-poster.legacy-storage-encoding'; + key: 'node.staker.data-poster.legacy-storage-encoding'; type: boolean; } | { /** mathematical formula to calculate maximum fee cap gwei the result of which would be float64. This expression is expected to be evaluated please refer https://github.com/Knetic/govaluate/blob/master/MANUAL.md to find all available mathematical operators. Currently available variables to construct the formula are BacklogOfBatches, UrgencyGWei, ElapsedTime, ElapsedTimeBase, ElapsedTimeImportance, and TargetPriceGWei (default "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei") */ - name: 'node.staker.data-poster.max-fee-cap-formula'; + key: 'node.staker.data-poster.max-fee-cap-formula'; type: string; } | { /** the maximum number of transactions to have queued in the mempool at once (0 = unlimited) (default 1) */ - name: 'node.staker.data-poster.max-mempool-transactions'; + key: 'node.staker.data-poster.max-mempool-transactions'; type: number; } | { /** the maximum number of unconfirmed transactions to track at once (0 = unlimited) */ - name: 'node.staker.data-poster.max-queued-transactions'; + key: 'node.staker.data-poster.max-queued-transactions'; type: number; } | { /** the maximum tip cap to post transactions at (default 5) */ - name: 'node.staker.data-poster.max-tip-cap-gwei'; + key: 'node.staker.data-poster.max-tip-cap-gwei'; type: number; } | { /** the minimum fee cap to post transactions at */ - name: 'node.staker.data-poster.min-fee-cap-gwei'; + key: 'node.staker.data-poster.min-fee-cap-gwei'; type: number; } | { /** the minimum tip cap to post transactions at (default 0.05) */ - name: 'node.staker.data-poster.min-tip-cap-gwei'; + key: 'node.staker.data-poster.min-tip-cap-gwei'; type: number; } | { /** the maximum probable reorg depth, used to determine when a transaction will no longer likely need replaced-by-fee (default 1) */ - name: 'node.staker.data-poster.nonce-rbf-soft-confs'; + key: 'node.staker.data-poster.nonce-rbf-soft-confs'; type: number; } | { /** disable message signature verification */ - name: 'node.staker.data-poster.redis-signer.dangerous.disable-signature-verification'; + key: 'node.staker.data-poster.redis-signer.dangerous.disable-signature-verification'; type: boolean; } | { /** a fallback key used for message verification */ - name: 'node.staker.data-poster.redis-signer.fallback-verification-key'; + key: 'node.staker.data-poster.redis-signer.fallback-verification-key'; type: string; } | { /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ - name: 'node.staker.data-poster.redis-signer.signing-key'; + key: 'node.staker.data-poster.redis-signer.signing-key'; type: string; } | { /** comma-separated list of durations since first posting to attempt a replace-by-fee (default "5m,10m,20m,30m,1h,2h,4h,6h,8h,12h,16h,18h,20h,22h") */ - name: 'node.staker.data-poster.replacement-times'; + key: 'node.staker.data-poster.replacement-times'; type: string; } | { /** the target price to use for maximum fee cap calculation (default 60) */ - name: 'node.staker.data-poster.target-price-gwei'; + key: 'node.staker.data-poster.target-price-gwei'; type: number; } | { /** the urgency to use for maximum fee cap calculation (default 2) */ - name: 'node.staker.data-poster.urgency-gwei'; + key: 'node.staker.data-poster.urgency-gwei'; type: number; } | { /** uses database storage when enabled (default true) */ - name: 'node.staker.data-poster.use-db-storage'; + key: 'node.staker.data-poster.use-db-storage'; type: boolean; } | { /** uses noop storage, it doesn't store anything */ - name: 'node.staker.data-poster.use-noop-storage'; + key: 'node.staker.data-poster.use-noop-storage'; type: boolean; } | { /** only treat a transaction as confirmed after L1 finality has been achieved (recommended) (default true) */ - name: 'node.staker.data-poster.wait-for-l1-finality'; + key: 'node.staker.data-poster.wait-for-l1-finality'; type: boolean; } | { /** disable validator challenge */ - name: 'node.staker.disable-challenge'; + key: 'node.staker.disable-challenge'; type: boolean; } | { /** enable validator (default true) */ - name: 'node.staker.enable'; + key: 'node.staker.enable'; type: boolean; } | { /** use this much more gas than estimation says is necessary to post transactions (default 50000) */ - name: 'node.staker.extra-gas'; + key: 'node.staker.extra-gas'; type: number; } | { /** The gas refunder contract address (optional) */ - name: 'node.staker.gas-refunder-address'; + key: 'node.staker.gas-refunder-address'; type: string; } | { /** if configured with the makeNodes strategy, how often to create new assertions (bypassed in case of a dispute) (default 1h0m0s) */ - name: 'node.staker.make-assertion-interval'; + key: 'node.staker.make-assertion-interval'; type: string; } | { /** only create smart wallet contract and exit */ - name: 'node.staker.only-create-wallet-contract'; + key: 'node.staker.only-create-wallet-contract'; type: boolean; } | { /** account to use (default is first account in keystore) */ - name: 'node.staker.parent-chain-wallet.account'; + key: 'node.staker.parent-chain-wallet.account'; type: string; } | { /** if true, creates new key then exits */ - name: 'node.staker.parent-chain-wallet.only-create-key'; + key: 'node.staker.parent-chain-wallet.only-create-key'; type: boolean; } | { /** wallet passphrase (default "PASSWORD_NOT_SET") */ - name: 'node.staker.parent-chain-wallet.password'; + key: 'node.staker.parent-chain-wallet.password'; type: string; } | { /** pathname for wallet (default "validator-wallet") */ - name: 'node.staker.parent-chain-wallet.pathname'; + key: 'node.staker.parent-chain-wallet.pathname'; type: string; } | { /** private key for wallet */ - name: 'node.staker.parent-chain-wallet.private-key'; + key: 'node.staker.parent-chain-wallet.private-key'; type: string; } | { /** high gas delay blocks */ - name: 'node.staker.posting-strategy.high-gas-delay-blocks'; + key: 'node.staker.posting-strategy.high-gas-delay-blocks'; type: number; } | { /** high gas threshold */ - name: 'node.staker.posting-strategy.high-gas-threshold'; + key: 'node.staker.posting-strategy.high-gas-threshold'; type: number; } | { /** redis url for L1 validator */ - name: 'node.staker.redis-url'; + key: 'node.staker.redis-url'; type: string; } | { /** how often the L1 validator should check the status of the L1 rollup and maybe take action with its stake (default 1m0s) */ - name: 'node.staker.staker-interval'; + key: 'node.staker.staker-interval'; type: string; } | { /** assume staked nodes are valid (default true) */ - name: 'node.staker.start-validation-from-staked'; + key: 'node.staker.start-validation-from-staked'; type: boolean; } | { /** L1 validator strategy, either watchtower, defensive, stakeLatest, or makeNodes (default "Watchtower") */ - name: 'node.staker.strategy'; + key: 'node.staker.strategy'; type: string; } | { /** use a smart contract wallet instead of an EOA address */ - name: 'node.staker.use-smart-contract-wallet'; + key: 'node.staker.use-smart-contract-wallet'; type: boolean; } | { /** allowed lag between messages read and blocks built (default 20) */ - name: 'node.sync-monitor.block-build-lag'; + key: 'node.sync-monitor.block-build-lag'; type: number; } | { /** allowed lag between messages read from sequencer inbox and blocks built */ - name: 'node.sync-monitor.block-build-sequencer-inbox-lag'; + key: 'node.sync-monitor.block-build-sequencer-inbox-lag'; type: number; } | { /** allowed lag between local and remote messages (default 15) */ - name: 'node.sync-monitor.coordinator-msg-lag'; + key: 'node.sync-monitor.coordinator-msg-lag'; type: number; } | { /** wait for block validator to complete before returning finalized block number */ - name: 'node.sync-monitor.finalized-block-wait-for-block-validator'; + key: 'node.sync-monitor.finalized-block-wait-for-block-validator'; type: boolean; } | { /** wait for block validator to complete before returning safe block number */ - name: 'node.sync-monitor.safe-block-wait-for-block-validator'; + key: 'node.sync-monitor.safe-block-wait-for-block-validator'; type: boolean; } | { /** delay when polling calls to execute messages (default 100ms) */ - name: 'node.transaction-streamer.execute-message-loop-delay'; + key: 'node.transaction-streamer.execute-message-loop-delay'; type: string; } | { /** maximum cache of pending broadcaster messages (default 50000) */ - name: 'node.transaction-streamer.max-broadcaster-queue-size'; + key: 'node.transaction-streamer.max-broadcaster-queue-size'; type: number; } | { /** maximum number of messages to attempt to resequence on reorg (0 = never resequence, -1 = always resequence) (default 1024) */ - name: 'node.transaction-streamer.max-reorg-resequence-depth'; + key: 'node.transaction-streamer.max-reorg-resequence-depth'; type: number; } | { /** P2P bootnodes */ - name: 'p2p.bootnodes'; + key: 'p2p.bootnodes'; type: string[]; } | { /** P2P bootnodes v5 */ - name: 'p2p.bootnodes-v5'; + key: 'p2p.bootnodes-v5'; type: string[]; } | { /** P2P discovery v4 */ - name: 'p2p.discovery-v4'; + key: 'p2p.discovery-v4'; type: boolean; } | { /** P2P discovery v5 */ - name: 'p2p.discovery-v5'; + key: 'p2p.discovery-v5'; type: boolean; } | { /** P2P listen address */ - name: 'p2p.listen-addr'; + key: 'p2p.listen-addr'; type: string; } | { /** P2P max peers (default 50) */ - name: 'p2p.max-peers'; + key: 'p2p.max-peers'; type: number; } | { /** P2P no dial (default true) */ - name: 'p2p.no-dial'; + key: 'p2p.no-dial'; type: boolean; } | { /** P2P no discovery (default true) */ - name: 'p2p.no-discovery'; + key: 'p2p.no-discovery'; type: boolean; } | { /** Beacon Chain RPC URL to use for fetching blobs (normally on port 3500) */ - name: 'parent-chain.blob-client.beacon-url'; + key: 'parent-chain.blob-client.beacon-url'; type: string; } | { /** Full path of the directory to save fetched blobs */ - name: 'parent-chain.blob-client.blob-directory'; + key: 'parent-chain.blob-client.blob-directory'; type: string; } | { /** limit size of arguments in log entries (default 2048) */ - name: 'parent-chain.connection.arg-log-limit'; + key: 'parent-chain.connection.arg-log-limit'; type: number; } | { /** how long to wait for initial connection (default 1m0s) */ - name: 'parent-chain.connection.connection-wait'; + key: 'parent-chain.connection.connection-wait'; type: string; } | { /** path to file with jwtsecret for validation - ignored if url is self or self-auth */ - name: 'parent-chain.connection.jwtsecret'; + key: 'parent-chain.connection.jwtsecret'; type: string; } | { /** number of retries in case of failure(0 mean one attempt) (default 2) */ - name: 'parent-chain.connection.retries'; + key: 'parent-chain.connection.retries'; type: number; } | { /** delay between retries */ - name: 'parent-chain.connection.retry-delay'; + key: 'parent-chain.connection.retry-delay'; type: string; } | { /** Errors matching this regular expression are automatically retried */ - name: 'parent-chain.connection.retry-errors'; + key: 'parent-chain.connection.retry-errors'; type: string; } | { /** per-response timeout (0-disabled) (default 1m0s) */ - name: 'parent-chain.connection.timeout'; + key: 'parent-chain.connection.timeout'; type: string; } | { /** url of server, use self for loopback websocket, self-auth for loopback with authentication */ - name: 'parent-chain.connection.url'; + key: 'parent-chain.connection.url'; type: string; } | { /** if set other than 0, will be used to validate database and L1 connection */ - name: 'parent-chain.id'; + key: 'parent-chain.id'; type: number; } | { /** account to use (default is first account in keystore) */ - name: 'parent-chain.wallet.account'; + key: 'parent-chain.wallet.account'; type: string; } | { /** if true, creates new key then exits */ - name: 'parent-chain.wallet.only-create-key'; + key: 'parent-chain.wallet.only-create-key'; type: boolean; } | { /** wallet passphrase (default "PASSWORD_NOT_SET") */ - name: 'parent-chain.wallet.password'; + key: 'parent-chain.wallet.password'; type: string; } | { /** pathname for wallet (default "wallet") */ - name: 'parent-chain.wallet.pathname'; + key: 'parent-chain.wallet.pathname'; type: string; } | { /** private key for wallet */ - name: 'parent-chain.wallet.private-key'; + key: 'parent-chain.wallet.private-key'; type: string; } | { /** directory of ancient where the chain freezer can be opened */ - name: 'persistent.ancient'; + key: 'persistent.ancient'; type: string; } | { /** directory to store chain state */ - name: 'persistent.chain'; + key: 'persistent.chain'; type: string; } | { /** backing database implementation to use ('leveldb' or 'pebble') (default "leveldb") */ - name: 'persistent.db-engine'; + key: 'persistent.db-engine'; type: string; } | { /** directory to store global config (default ".arbitrum") */ - name: 'persistent.global-config'; + key: 'persistent.global-config'; type: string; } | { /** number of file descriptor handles to use for the database (default 512) */ - name: 'persistent.handles'; + key: 'persistent.handles'; type: number; } | { /** directory to store log file */ - name: 'persistent.log-dir'; + key: 'persistent.log-dir'; type: string; } | { /** enable pprof */ - name: 'pprof'; + key: 'pprof'; type: boolean; } | { /** pprof server address (default "127.0.0.1") */ - name: 'pprof-cfg.addr'; + key: 'pprof-cfg.addr'; type: string; } | { /** pprof server port (default 6071) */ - name: 'pprof-cfg.port'; + key: 'pprof-cfg.port'; type: number; } | { /** the maximum number of requests in a batch (0 means no limit) (default 1000) */ - name: 'rpc.batch-request-limit'; + key: 'rpc.batch-request-limit'; type: number; } | { /** the maximum response size for a JSON-RPC request measured in bytes (0 means no limit) (default 10000000) */ - name: 'rpc.max-batch-response-size'; + key: 'rpc.max-batch-response-size'; type: number; } | { /** validate is an authenticated API (default true) */ - name: 'validation.api-auth'; + key: 'validation.api-auth'; type: boolean; } | { /** validate is a public API */ - name: 'validation.api-public'; + key: 'validation.api-public'; type: boolean; } | { /** timeout before discarding execution run (default 15m0s) */ - name: 'validation.arbitrator.execution-run-timeout'; + key: 'validation.arbitrator.execution-run-timeout'; type: string; } | { /** how many machines to store in cache while working on a challenge (should be even) (default 4) */ - name: 'validation.arbitrator.execution.cached-challenge-machines'; + key: 'validation.arbitrator.execution.cached-challenge-machines'; type: number; } | { /** initial steps between machines (default 100000) */ - name: 'validation.arbitrator.execution.initial-steps'; + key: 'validation.arbitrator.execution.initial-steps'; type: number; } | { /** path to write machines to (default "./target/output") */ - name: 'validation.arbitrator.output-path'; + key: 'validation.arbitrator.output-path'; type: string; } | { /** number of concurrent validation threads */ - name: 'validation.arbitrator.workers'; + key: 'validation.arbitrator.workers'; type: number; } | { /** use Cranelift instead of LLVM when validating blocks using the jit-accelerated block validator (default true) */ - name: 'validation.jit.cranelift'; + key: 'validation.jit.cranelift'; type: boolean; } | { /** if memory used by a jit wasm exceeds this limit, a warning is logged (default 4294967296) */ - name: 'validation.jit.wasm-memory-usage-limit'; + key: 'validation.jit.wasm-memory-usage-limit'; type: number; } | { /** number of concurrent validation threads */ - name: 'validation.jit.workers'; + key: 'validation.jit.workers'; type: number; } | { /** use jit for validation (default true) */ - name: 'validation.use-jit'; + key: 'validation.use-jit'; type: boolean; } | { /** list of WASM module roots to check if the on-chain WASM module root belongs to on node startup */ - name: 'validation.wasm.allowed-wasm-module-roots'; + key: 'validation.wasm.allowed-wasm-module-roots'; type: string[]; } | { /** enable check for compatibility of on-chain WASM module root with node (default true) */ - name: 'validation.wasm.enable-wasmroots-check'; + key: 'validation.wasm.enable-wasmroots-check'; type: boolean; } | { /** path to machine folders, each containing wasm files (machine.wavm.br, replay.wasm) */ - name: 'validation.wasm.root-path'; + key: 'validation.wasm.root-path'; type: string; } | { /** WS-RPC server listening interface */ - name: 'ws.addr'; + key: 'ws.addr'; type: string; } | { /** APIs offered over the WS-RPC interface (default [net,web3,eth,arb]) */ - name: 'ws.api'; + key: 'ws.api'; type: string[]; } | { /** expose private api via websocket */ - name: 'ws.expose-all'; + key: 'ws.expose-all'; type: boolean; } | { /** Origins from which to accept websockets requests */ - name: 'ws.origins'; + key: 'ws.origins'; type: string[]; } | { /** WS-RPC server listening port (default 8548) */ - name: 'ws.port'; + key: 'ws.port'; type: number; } | { /** WS path path prefix on which JSON-RPC is served. Use '/' to serve on all paths */ - name: 'ws.rpcprefix'; + key: 'ws.rpcprefix'; type: string; }; From d419dfde33a016325dd81c85b2b9ba90ac7ebb17 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Thu, 29 Feb 2024 18:21:42 +0100 Subject: [PATCH 11/24] fix --- src/nodeConfigBuilder.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index c9e37ec7..905f23bf 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -7,7 +7,7 @@ export type NodeConfigOptionKey = NodeConfigOption['key']; export type NodeConfigOptionGetType = Extract< NodeConfigOption, - { name: TKey } + { key: TKey } >['type']; const config = { From 46dc5e00991c2377aefc292b022f68e636f80b08 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Tue, 5 Mar 2024 14:47:56 +0100 Subject: [PATCH 12/24] progress --- .../nodeConfigBuilder.unit.test.ts.snap | 123 ++++++++---- src/index.ts | 3 +- src/nodeConfigBuilder.ts | 175 ++++++++++++++++-- src/nodeConfigBuilder.unit.test.ts | 61 +++++- src/nodeConfigBuilderDefaults.ts | 109 ----------- src/nodeConfigBuilderUtils.ts | 32 ++++ 6 files changed, 329 insertions(+), 174 deletions(-) create mode 100644 src/nodeConfigBuilderUtils.ts diff --git a/src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap b/src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap index 116d4330..14ec7fd0 100644 --- a/src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap +++ b/src/__snapshots__/nodeConfigBuilder.unit.test.ts.snap @@ -1,17 +1,42 @@ // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html -exports[`creates node config with defaults 1`] = ` +exports[`creates node config 1`] = ` { - "execution": { - "caching": { - "archive": true, - }, - "forwarding-target": "", - "sequencer": { - "enable": true, - "max-block-speed": "250ms", - "max-tx-data-size": 85000, + "chain": { + "info-json": "[{\\"chain-id\\":123456,\\"chain-name\\":\\"my-l3-chain\\",\\"chain-config\\":{\\"homesteadBlock\\":0,\\"daoForkBlock\\":null,\\"daoForkSupport\\":true,\\"eip150Block\\":0,\\"eip150Hash\\":\\"0x0000000000000000000000000000000000000000000000000000000000000000\\",\\"eip155Block\\":0,\\"eip158Block\\":0,\\"byzantiumBlock\\":0,\\"constantinopleBlock\\":0,\\"petersburgBlock\\":0,\\"istanbulBlock\\":0,\\"muirGlacierBlock\\":0,\\"berlinBlock\\":0,\\"londonBlock\\":0,\\"clique\\":{\\"period\\":0,\\"epoch\\":0},\\"arbitrum\\":{\\"EnableArbOS\\":true,\\"AllowDebugPrecompiles\\":false,\\"DataAvailabilityCommittee\\":false,\\"InitialArbOSVersion\\":11,\\"GenesisBlockNum\\":0,\\"MaxCodeSize\\":24576,\\"MaxInitCodeSize\\":49152,\\"InitialChainOwner\\":\\"0x1000000000000000000000000000000000000000\\"},\\"chainId\\":123456},\\"parent-chain-id\\":421614,\\"parent-chain-is-arbitrum\\":true,\\"rollup\\":{\\"bridge\\":\\"0x0000000000000000000000000000000000000001\\",\\"inbox\\":\\"0x0000000000000000000000000000000000000002\\",\\"sequencer-inbox\\":\\"0x0000000000000000000000000000000000000003\\",\\"rollup\\":\\"0x0000000000000000000000000000000000000004\\",\\"validator-utils\\":\\"0x0000000000000000000000000000000000000005\\",\\"validator-wallet-creator\\":\\"0x0000000000000000000000000000000000000006\\",\\"deployed-at\\":456789}}]", + "name": "my-l3-chain", + }, + "http": { + "addr": "0.0.0.0", + "api": [ + "eth", + "net", + "web3", + "arb", + "debug", + ], + "corsdomain": [ + "*", + ], + "port": 8449, + "vhosts": [ + "*", + ], + }, + "parent-chain": { + "connection": { + "url": "https://sepolia-rollup.arbitrum.io/rpc", }, + "id": 421614, + }, +} +`; + +exports[`creates node config with data availability service 1`] = ` +{ + "chain": { + "info-json": "[{\\"chain-id\\":123456,\\"chain-name\\":\\"my-l3-chain\\",\\"chain-config\\":{\\"homesteadBlock\\":0,\\"daoForkBlock\\":null,\\"daoForkSupport\\":true,\\"eip150Block\\":0,\\"eip150Hash\\":\\"0x0000000000000000000000000000000000000000000000000000000000000000\\",\\"eip155Block\\":0,\\"eip158Block\\":0,\\"byzantiumBlock\\":0,\\"constantinopleBlock\\":0,\\"petersburgBlock\\":0,\\"istanbulBlock\\":0,\\"muirGlacierBlock\\":0,\\"berlinBlock\\":0,\\"londonBlock\\":0,\\"clique\\":{\\"period\\":0,\\"epoch\\":0},\\"arbitrum\\":{\\"EnableArbOS\\":true,\\"AllowDebugPrecompiles\\":false,\\"DataAvailabilityCommittee\\":false,\\"InitialArbOSVersion\\":11,\\"GenesisBlockNum\\":0,\\"MaxCodeSize\\":24576,\\"MaxInitCodeSize\\":49152,\\"InitialChainOwner\\":\\"0x1000000000000000000000000000000000000000\\"},\\"chainId\\":123456},\\"parent-chain-id\\":421614,\\"parent-chain-is-arbitrum\\":true,\\"rollup\\":{\\"bridge\\":\\"0x0000000000000000000000000000000000000001\\",\\"inbox\\":\\"0x0000000000000000000000000000000000000002\\",\\"sequencer-inbox\\":\\"0x0000000000000000000000000000000000000003\\",\\"rollup\\":\\"0x0000000000000000000000000000000000000004\\",\\"validator-utils\\":\\"0x0000000000000000000000000000000000000005\\",\\"validator-wallet-creator\\":\\"0x0000000000000000000000000000000000000006\\",\\"deployed-at\\":456789}}]", + "name": "my-l3-chain", }, "http": { "addr": "0.0.0.0", @@ -31,29 +56,36 @@ exports[`creates node config with defaults 1`] = ` ], }, "node": { - "batch-poster": { - "enable": true, - "max-size": 90000, - }, - "dangerous": { - "no-sequencer-coordinator": true, - }, - "delayed-sequencer": { + "data-availability": { "enable": true, - "finalize-distance": 1, - "use-merge-finality": false, + "rest-aggregator": { + "enable": true, + "urls": [ + "http://localhost:9877", + ], + }, + "rpc-aggregator": { + "assumed-honest": 1, + "backends": "[{\\"url\\":\\"http://localhost:9876\\",\\"pubkey\\":\\"YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==\\",\\"signermask\\":1}]", + "enable": true, + }, }, - "sequencer": true, - "staker": { - "enable": true, - "strategy": "MakeNodes", + }, + "parent-chain": { + "connection": { + "url": "https://sepolia-rollup.arbitrum.io/rpc", }, + "id": 421614, }, } `; -exports[`creates node config with defaults including data availability 1`] = ` +exports[`creates node config with sequencer, batch poster and staker 1`] = ` { + "chain": { + "info-json": "[{\\"chain-id\\":123456,\\"chain-name\\":\\"my-l3-chain\\",\\"chain-config\\":{\\"homesteadBlock\\":0,\\"daoForkBlock\\":null,\\"daoForkSupport\\":true,\\"eip150Block\\":0,\\"eip150Hash\\":\\"0x0000000000000000000000000000000000000000000000000000000000000000\\",\\"eip155Block\\":0,\\"eip158Block\\":0,\\"byzantiumBlock\\":0,\\"constantinopleBlock\\":0,\\"petersburgBlock\\":0,\\"istanbulBlock\\":0,\\"muirGlacierBlock\\":0,\\"berlinBlock\\":0,\\"londonBlock\\":0,\\"clique\\":{\\"period\\":0,\\"epoch\\":0},\\"arbitrum\\":{\\"EnableArbOS\\":true,\\"AllowDebugPrecompiles\\":false,\\"DataAvailabilityCommittee\\":false,\\"InitialArbOSVersion\\":11,\\"GenesisBlockNum\\":0,\\"MaxCodeSize\\":24576,\\"MaxInitCodeSize\\":49152,\\"InitialChainOwner\\":\\"0x1000000000000000000000000000000000000000\\"},\\"chainId\\":123456},\\"parent-chain-id\\":421614,\\"parent-chain-is-arbitrum\\":true,\\"rollup\\":{\\"bridge\\":\\"0x0000000000000000000000000000000000000001\\",\\"inbox\\":\\"0x0000000000000000000000000000000000000002\\",\\"sequencer-inbox\\":\\"0x0000000000000000000000000000000000000003\\",\\"rollup\\":\\"0x0000000000000000000000000000000000000004\\",\\"validator-utils\\":\\"0x0000000000000000000000000000000000000005\\",\\"validator-wallet-creator\\":\\"0x0000000000000000000000000000000000000006\\",\\"deployed-at\\":456789}}]", + "name": "my-l3-chain", + }, "execution": { "caching": { "archive": true, @@ -86,24 +118,13 @@ exports[`creates node config with defaults including data availability 1`] = ` "batch-poster": { "enable": true, "max-size": 90000, + "parent-chain-wallet": { + "private-key": "BATCH_POSTER_PRIVATE_KEY", + }, }, "dangerous": { "no-sequencer-coordinator": true, }, - "data-availability": { - "enable": true, - "rest-aggregator": { - "enable": true, - "urls": [ - "http://localhost:9877", - ], - }, - "rpc-aggregator": { - "assumed-honest": 1, - "backends": "[{\\"url\\":\\"http://localhost:9876\\",\\"pubkey\\":\\"YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==\\",\\"signermask\\":1}]", - "enable": true, - }, - }, "delayed-sequencer": { "enable": true, "finalize-distance": 1, @@ -112,10 +133,32 @@ exports[`creates node config with defaults including data availability 1`] = ` "sequencer": true, "staker": { "enable": true, + "parent-chain-wallet": { + "private-key": "STAKER_PRIVATE_KEY", + }, "strategy": "MakeNodes", }, }, + "parent-chain": { + "connection": { + "url": "https://sepolia-rollup.arbitrum.io/rpc", + }, + "id": 421614, + }, } `; -exports[`creates node config without defaults 1`] = `{}`; +exports[`creates node config without defaults 1`] = ` +{ + "chain": { + "info-json": "[{\\"chain-id\\":123456,\\"chain-name\\":\\"my-l3-chain\\",\\"chain-config\\":{\\"homesteadBlock\\":0,\\"daoForkBlock\\":null,\\"daoForkSupport\\":true,\\"eip150Block\\":0,\\"eip150Hash\\":\\"0x0000000000000000000000000000000000000000000000000000000000000000\\",\\"eip155Block\\":0,\\"eip158Block\\":0,\\"byzantiumBlock\\":0,\\"constantinopleBlock\\":0,\\"petersburgBlock\\":0,\\"istanbulBlock\\":0,\\"muirGlacierBlock\\":0,\\"berlinBlock\\":0,\\"londonBlock\\":0,\\"clique\\":{\\"period\\":0,\\"epoch\\":0},\\"arbitrum\\":{\\"EnableArbOS\\":true,\\"AllowDebugPrecompiles\\":false,\\"DataAvailabilityCommittee\\":false,\\"InitialArbOSVersion\\":11,\\"GenesisBlockNum\\":0,\\"MaxCodeSize\\":24576,\\"MaxInitCodeSize\\":49152,\\"InitialChainOwner\\":\\"0x1000000000000000000000000000000000000000\\"},\\"chainId\\":123456},\\"parent-chain-id\\":421614,\\"parent-chain-is-arbitrum\\":true,\\"rollup\\":{\\"bridge\\":\\"0x0000000000000000000000000000000000000001\\",\\"inbox\\":\\"0x0000000000000000000000000000000000000002\\",\\"sequencer-inbox\\":\\"0x0000000000000000000000000000000000000003\\",\\"rollup\\":\\"0x0000000000000000000000000000000000000004\\",\\"validator-utils\\":\\"0x0000000000000000000000000000000000000005\\",\\"validator-wallet-creator\\":\\"0x0000000000000000000000000000000000000006\\",\\"deployed-at\\":456789}}]", + "name": "my-l3-chain", + }, + "parent-chain": { + "connection": { + "url": "https://sepolia-rollup.arbitrum.io/rpc", + }, + "id": 421614, + }, +} +`; diff --git a/src/index.ts b/src/index.ts index 55d3ef61..0fb842e9 100644 --- a/src/index.ts +++ b/src/index.ts @@ -45,7 +45,7 @@ import { import { ChainConfig, ChainConfigArbitrumParams } from './types/ChainConfig'; import { CoreContracts } from './types/CoreContracts'; import { ParentChain, ParentChainId } from './types/ParentChain'; -import { NodeConfig } from './types/NodeConfig.generated'; +import { NodeConfig, NodeConfigOption } from './types/NodeConfig.generated'; import { NodeConfigChainInfoJson } from './types/NodeConfig'; import { prepareNodeConfig } from './prepareNodeConfig'; import { @@ -104,6 +104,7 @@ export { ParentChain, ParentChainId, NodeConfig, + NodeConfigOption, NodeConfigChainInfoJson, prepareNodeConfig, prepareKeyset, diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index 905f23bf..cd21bd88 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -1,7 +1,13 @@ import { NodeConfig, NodeConfigOption } from './types/NodeConfig.generated'; -import { getNodeConfigBuilderDefaults } from './nodeConfigBuilderDefaults'; - -// todo: is there a way to make jsdoc readable when working with the builder? +import { CoreContracts } from './types/CoreContracts'; +import { parentChainIsArbitrum, stringifyJson } from './nodeConfigBuilderUtils'; +import { nodeConfigBuilderDefaults } from './nodeConfigBuilderDefaults'; +import { ParentChainId } from './types/ParentChain'; +import { ChainConfig } from './types/ChainConfig'; +import { + NodeConfigChainInfoJson, + NodeConfigDataAvailabilityRpcAggregatorBackendsJson, +} from './types/NodeConfig'; export type NodeConfigOptionKey = NodeConfigOption['key']; @@ -10,30 +16,142 @@ export type NodeConfigOptionGetType = Extract< { key: TKey } >['type']; -const config = { - auth: { - /** - * cool cool - */ - api: 'auth.api', - /** - * asdf asdf - */ - addr: 'auth.addr', - }, -} as const; +export type NodeConfigBuilderEnableBatchPosterParams = { + privateKey: string; +}; + +export type NodeConfigBuilderEnableStakerParams = { + privateKey: string; +}; export class NodeConfigBuilder { private nodeConfig: NodeConfig; + private isInitialized: boolean; constructor(initialNodeConfig?: NodeConfig) { this.nodeConfig = initialNodeConfig ?? {}; + this.isInitialized = false; + } + + private prepareChainInfoJson(params: InitializeThings): NodeConfigChainInfoJson { + return [ + { + 'chain-id': params.chain.id, + 'chain-name': params.chain.name, + 'chain-config': params.chain.config, + 'parent-chain-id': params.parentChain.id, + 'parent-chain-is-arbitrum': parentChainIsArbitrum(params.parentChain.id), + 'rollup': { + 'bridge': params.parentChain.coreContracts.bridge, + 'inbox': params.parentChain.coreContracts.inbox, + 'sequencer-inbox': params.parentChain.coreContracts.sequencerInbox, + 'rollup': params.parentChain.coreContracts.rollup, + 'validator-utils': params.parentChain.coreContracts.validatorUtils, + 'validator-wallet-creator': params.parentChain.coreContracts.validatorWalletCreator, + 'deployed-at': params.parentChain.coreContracts.deployedAtBlockNumber, + }, + }, + ]; + } + + public initialize(params: InitializeThings): NodeConfigBuilder { + const chainInfoJson = stringifyJson(this.prepareChainInfoJson(params)); + + this.set('chain.name', params.chain.name); + this.set('chain.info-json', chainInfoJson); + + this.set('parent-chain.id', params.parentChain.id); + this.set('parent-chain.connection.url', params.parentChain.rpcUrl); + + this.isInitialized = true; + + return this; + } + + public enableSequencer(): NodeConfigBuilder { + this.set('node.sequencer', true); + + this.set('node.delayed-sequencer.enable', true); + this.set('node.delayed-sequencer.use-merge-finality', false); + this.set('node.delayed-sequencer.finalize-distance', 1); + + this.set('node.dangerous.no-sequencer-coordinator', true); + + this.set('execution.forwarding-target', ''); + + this.set('execution.sequencer.enable', true); + this.set('execution.sequencer.max-tx-data-size', 85_000); + this.set('execution.sequencer.max-block-speed', '250ms'); + + this.set('execution.caching.archive', true); + + return this; + } + + public enableBatchPoster(params: NodeConfigBuilderEnableBatchPosterParams): NodeConfigBuilder { + this.set('node.batch-poster.enable', true); + this.set('node.batch-poster.max-size', 90_000); + this.set('node.batch-poster.parent-chain-wallet.private-key', params.privateKey); + + return this; + } + + public enableStaker(params: NodeConfigBuilderEnableStakerParams): NodeConfigBuilder { + this.set('node.staker.enable', true); + this.set('node.staker.strategy', 'MakeNodes'); + this.set('node.staker.parent-chain-wallet.private-key', params.privateKey); + + return this; + } + + public enableDataAvailabilityService(): NodeConfigBuilder { + const backendsJson = stringifyJson([ + { + url: 'http://localhost:9876', + pubkey: + 'YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==', + signermask: 1, + }, + ]); + + this.set('node.data-availability.enable', true); + + this.set('node.data-availability.rest-aggregator.enable', true); + this.set('node.data-availability.rest-aggregator.urls', ['http://localhost:9877']); + + this.set('node.data-availability.rpc-aggregator.enable', true); + this.set('node.data-availability.rpc-aggregator.assumed-honest', 1); + this.set('node.data-availability.rpc-aggregator.backends', backendsJson); + + return this; } set( key: TKey, value: NodeConfigOptionGetType, ): NodeConfigBuilder { + // if (!this.isInitialized) { + // throw new Error(`You must first call ".initialize()" on the builder`); + // } + + const keys = key.split('.'); + let currentObject = this.nodeConfig; + + for (let i = 0; i < keys.length - 1; i++) { + const currentKey = keys[i]; + // @ts-ignore + if (!currentObject[currentKey]) { + // @ts-ignore + currentObject[currentKey] = {}; + } + // @ts-ignore + currentObject = currentObject[currentKey]; + } + + const finalKey = keys[keys.length - 1]; + // @ts-ignore + currentObject[finalKey] = value; + return this; } @@ -42,9 +160,32 @@ export class NodeConfigBuilder { } } +type NodeConfigCoreContracts = Pick< + CoreContracts, + | 'bridge' + | 'inbox' + | 'sequencerInbox' + | 'rollup' + | 'validatorUtils' + | 'validatorWalletCreator' + | 'deployedAtBlockNumber' +>; + +export type InitializeThings = { + chain: { + id: number; + name: string; + config: ChainConfig; + }; + parentChain: { + id: ParentChainId; + rpcUrl: string; + coreContracts: NodeConfigCoreContracts; + }; +}; + export type CreateNodeConfigBuilderParams = { withDefaults?: boolean; - withDataAvailability?: boolean; }; export function createNodeConfigBuilder(params?: CreateNodeConfigBuilderParams): NodeConfigBuilder { @@ -54,5 +195,5 @@ export function createNodeConfigBuilder(params?: CreateNodeConfigBuilderParams): return new NodeConfigBuilder(); } - return new NodeConfigBuilder(getNodeConfigBuilderDefaults(params)); + return new NodeConfigBuilder(nodeConfigBuilderDefaults); } diff --git a/src/nodeConfigBuilder.unit.test.ts b/src/nodeConfigBuilder.unit.test.ts index b2c7c7d8..0b1f15a0 100644 --- a/src/nodeConfigBuilder.unit.test.ts +++ b/src/nodeConfigBuilder.unit.test.ts @@ -1,18 +1,65 @@ import { it, expect } from 'vitest'; -import { createNodeConfigBuilder } from './nodeConfigBuilder'; +import { createNodeConfigBuilder, InitializeThings } from './nodeConfigBuilder'; +import { prepareChainConfig } from './prepareChainConfig'; + +const initializeParams: InitializeThings = { + chain: { + id: 123_456, + name: 'my-l3-chain', + config: prepareChainConfig({ + chainId: 123_456, + arbitrum: { InitialChainOwner: '0x1000000000000000000000000000000000000000' }, + }), + }, + parentChain: { + id: 421_614, + rpcUrl: 'https://sepolia-rollup.arbitrum.io/rpc', + coreContracts: { + bridge: '0x0000000000000000000000000000000000000001', + inbox: '0x0000000000000000000000000000000000000002', + sequencerInbox: '0x0000000000000000000000000000000000000003', + rollup: '0x0000000000000000000000000000000000000004', + validatorUtils: '0x0000000000000000000000000000000000000005', + validatorWalletCreator: '0x0000000000000000000000000000000000000006', + deployedAtBlockNumber: 456_789, + }, + }, +}; + +it('creates node config', () => { + const nodeConfig = createNodeConfigBuilder() + // + .initialize(initializeParams) + .build(); -it('creates node config with defaults', () => { - const nodeConfig = createNodeConfigBuilder().build(); expect(nodeConfig).toMatchSnapshot(); }); -it('creates node config with defaults including data availability', () => { - const nodeConfig = createNodeConfigBuilder({ withDataAvailability: true }).build(); +it('creates node config without defaults', () => { + const nodeConfig = createNodeConfigBuilder({ withDefaults: false }) + .initialize(initializeParams) + .build(); + expect(nodeConfig).toMatchSnapshot(); }); -it('creates node config without defaults', () => { - const nodeConfig = createNodeConfigBuilder({ withDefaults: false }).build(); +it('creates node config with data availability service', () => { + const nodeConfig = createNodeConfigBuilder() + .initialize(initializeParams) + .enableDataAvailabilityService() + .build(); + + expect(nodeConfig).toMatchSnapshot(); +}); + +it('creates node config with sequencer, batch poster and staker', () => { + const nodeConfig = createNodeConfigBuilder() + .initialize(initializeParams) + .enableSequencer() + .enableBatchPoster({ privateKey: 'BATCH_POSTER_PRIVATE_KEY' }) + .enableStaker({ privateKey: 'STAKER_PRIVATE_KEY' }) + .build(); + expect(nodeConfig).toMatchSnapshot(); }); diff --git a/src/nodeConfigBuilderDefaults.ts b/src/nodeConfigBuilderDefaults.ts index 6f4bb063..8aaafa1d 100644 --- a/src/nodeConfigBuilderDefaults.ts +++ b/src/nodeConfigBuilderDefaults.ts @@ -1,11 +1,4 @@ import { NodeConfig } from './types/NodeConfig.generated'; -import { NodeConfigDataAvailabilityRpcAggregatorBackendsJson } from './types/NodeConfig'; - -function stringifyBackendsJson( - backendsJson: NodeConfigDataAvailabilityRpcAggregatorBackendsJson, -): string { - return JSON.stringify(backendsJson); -} export const nodeConfigBuilderDefaults: NodeConfig = { http: { @@ -15,106 +8,4 @@ export const nodeConfigBuilderDefaults: NodeConfig = { corsdomain: ['*'], api: ['eth', 'net', 'web3', 'arb', 'debug'], }, - node: { - 'sequencer': true, - 'delayed-sequencer': { - 'enable': true, - 'use-merge-finality': false, - 'finalize-distance': 1, - }, - 'batch-poster': { - 'max-size': 90000, - 'enable': true, - }, - 'staker': { - enable: true, - strategy: 'MakeNodes', - }, - 'dangerous': { - 'no-sequencer-coordinator': true, - }, - }, - execution: { - 'forwarding-target': '', - 'sequencer': { - 'enable': true, - 'max-tx-data-size': 85000, - 'max-block-speed': '250ms', - }, - 'caching': { - archive: true, - }, - }, -}; - -export type GetNodeConfigBuilderDefaultsParams = { - withDataAvailability?: boolean; }; - -export function getNodeConfigBuilderDefaults( - params?: GetNodeConfigBuilderDefaultsParams, -): NodeConfig { - let defaults: NodeConfig = { - http: { - addr: '0.0.0.0', - port: 8449, - vhosts: ['*'], - corsdomain: ['*'], - api: ['eth', 'net', 'web3', 'arb', 'debug'], - }, - node: { - 'sequencer': true, - 'delayed-sequencer': { - 'enable': true, - 'use-merge-finality': false, - 'finalize-distance': 1, - }, - 'batch-poster': { - 'max-size': 90000, - 'enable': true, - }, - 'staker': { - enable: true, - strategy: 'MakeNodes', - }, - 'dangerous': { - 'no-sequencer-coordinator': true, - }, - }, - execution: { - 'forwarding-target': '', - 'sequencer': { - 'enable': true, - 'max-tx-data-size': 85000, - 'max-block-speed': '250ms', - }, - 'caching': { - archive: true, - }, - }, - }; - - if (params?.withDataAvailability ?? false) { - defaults.node!['data-availability'] = { - 'enable': true, - 'rest-aggregator': { - enable: true, - urls: ['http://localhost:9877'], - }, - 'rpc-aggregator': { - 'enable': true, - 'assumed-honest': 1, - 'backends': stringifyBackendsJson([ - { - url: 'http://localhost:9876', - pubkey: - 'YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==', - signermask: 1, - }, - ]), - }, - }; - } - - return defaults; -} diff --git a/src/nodeConfigBuilderUtils.ts b/src/nodeConfigBuilderUtils.ts new file mode 100644 index 00000000..6ef55c40 --- /dev/null +++ b/src/nodeConfigBuilderUtils.ts @@ -0,0 +1,32 @@ +import { ParentChainId } from './types/ParentChain'; +import { + mainnet, + arbitrumOne, + arbitrumNova, + sepolia, + arbitrumSepolia, + nitroTestnodeL1, + nitroTestnodeL2, + nitroTestnodeL3, +} from './chains'; + +export function parentChainIsArbitrum(parentChainId: ParentChainId): boolean { + // doing switch here to make sure it's exhaustive when checking against `ParentChainId` + switch (parentChainId) { + case mainnet.id: + case sepolia.id: + case nitroTestnodeL1.id: + return false; + + case arbitrumOne.id: + case arbitrumNova.id: + case arbitrumSepolia.id: + case nitroTestnodeL2.id: + case nitroTestnodeL3.id: + return true; + } +} + +export function stringifyJson(json: TJson): string { + return JSON.stringify(json); +} From e07dde0f50459e03caf47591fb6961db58005fed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dragi=C5=A1a=20Spasojevi=C4=87?= Date: Tue, 19 Mar 2024 12:18:05 +0100 Subject: [PATCH 13/24] enable das params --- src/nodeConfigBuilder.ts | 42 +++++++++++++++++++++--------- src/nodeConfigBuilder.unit.test.ts | 16 +++++++++++- src/types/NodeConfig.ts | 12 ++++----- 3 files changed, 50 insertions(+), 20 deletions(-) diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index cd21bd88..6f935fb9 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -24,6 +24,22 @@ export type NodeConfigBuilderEnableStakerParams = { privateKey: string; }; +export type RpcAggregatorBackendsItem = { + url: string; + pubkey: string; + signermask: number; +}; + +export type NodeConfigBuilderEnableDataAvailabilityServiceParams = { + restAggregator: { + urls: string[]; + }; + rpcAggregator: { + assumedHonest?: undefined; + backends: RpcAggregatorBackendsItem[]; + }; +}; + export class NodeConfigBuilder { private nodeConfig: NodeConfig; private isInitialized: boolean; @@ -104,24 +120,26 @@ export class NodeConfigBuilder { return this; } - public enableDataAvailabilityService(): NodeConfigBuilder { - const backendsJson = stringifyJson([ - { - url: 'http://localhost:9876', - pubkey: - 'YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==', - signermask: 1, - }, - ]); + public enableDataAvailabilityService( + params: NodeConfigBuilderEnableDataAvailabilityServiceParams, + ): NodeConfigBuilder { + const backends = params.rpcAggregator.backends.map((backend, index) => ({ + ...backend, + signermask: 1 << index, // 2^n + })); + + const rpcAggregatorAssumedHonest = params.rpcAggregator.assumedHonest ?? 1; + const rpcAggregatorBackendsJson = + stringifyJson(backends); this.set('node.data-availability.enable', true); this.set('node.data-availability.rest-aggregator.enable', true); - this.set('node.data-availability.rest-aggregator.urls', ['http://localhost:9877']); + this.set('node.data-availability.rest-aggregator.urls', params.restAggregator.urls); this.set('node.data-availability.rpc-aggregator.enable', true); - this.set('node.data-availability.rpc-aggregator.assumed-honest', 1); - this.set('node.data-availability.rpc-aggregator.backends', backendsJson); + this.set('node.data-availability.rpc-aggregator.assumed-honest', rpcAggregatorAssumedHonest); + this.set('node.data-availability.rpc-aggregator.backends', rpcAggregatorBackendsJson); return this; } diff --git a/src/nodeConfigBuilder.unit.test.ts b/src/nodeConfigBuilder.unit.test.ts index 0b1f15a0..7000c57c 100644 --- a/src/nodeConfigBuilder.unit.test.ts +++ b/src/nodeConfigBuilder.unit.test.ts @@ -47,7 +47,21 @@ it('creates node config without defaults', () => { it('creates node config with data availability service', () => { const nodeConfig = createNodeConfigBuilder() .initialize(initializeParams) - .enableDataAvailabilityService() + .enableDataAvailabilityService({ + restAggregator: { + urls: ['http://localhost:9877'], + }, + rpcAggregator: { + backends: [ + { + url: 'http://localhost:9876', + pubkey: + 'YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==', + signermask: 1, + }, + ], + }, + }) .build(); expect(nodeConfig).toMatchSnapshot(); diff --git a/src/types/NodeConfig.ts b/src/types/NodeConfig.ts index ac7bcf06..b23c9198 100644 --- a/src/types/NodeConfig.ts +++ b/src/types/NodeConfig.ts @@ -19,10 +19,8 @@ export type NodeConfigChainInfoJson = [ }, ]; -export type NodeConfigDataAvailabilityRpcAggregatorBackendsJson = [ - { - url: string; - pubkey: string; - signermask: number; - }, -]; +export type NodeConfigDataAvailabilityRpcAggregatorBackendsJson = { + url: string; + pubkey: string; + signermask: number; +}[]; From 3fbb16e71ef4718903cc924175363333f7576abc Mon Sep 17 00:00:00 2001 From: spsjvc Date: Tue, 19 Mar 2024 15:14:52 +0100 Subject: [PATCH 14/24] use lodash set --- package.json | 1 + src/nodeConfigBuilder.ts | 20 +++----------------- src/package.json | 3 ++- yarn.lock | 17 +++++++++++++++++ 4 files changed, 23 insertions(+), 18 deletions(-) diff --git a/package.json b/package.json index 62c4aa9b..7e3c7a92 100644 --- a/package.json +++ b/package.json @@ -20,6 +20,7 @@ }, "devDependencies": { "@offchainlabs/prettier-config": "0.2.1", + "@types/lodash.set": "^4.3.9", "@wagmi/cli": "^1.5.2", "dotenv": "^16.3.1", "patch-package": "^8.0.0", diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index 6f935fb9..846361d4 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -1,3 +1,5 @@ +import _set from 'lodash.set'; + import { NodeConfig, NodeConfigOption } from './types/NodeConfig.generated'; import { CoreContracts } from './types/CoreContracts'; import { parentChainIsArbitrum, stringifyJson } from './nodeConfigBuilderUtils'; @@ -152,23 +154,7 @@ export class NodeConfigBuilder { // throw new Error(`You must first call ".initialize()" on the builder`); // } - const keys = key.split('.'); - let currentObject = this.nodeConfig; - - for (let i = 0; i < keys.length - 1; i++) { - const currentKey = keys[i]; - // @ts-ignore - if (!currentObject[currentKey]) { - // @ts-ignore - currentObject[currentKey] = {}; - } - // @ts-ignore - currentObject = currentObject[currentKey]; - } - - const finalKey = keys[keys.length - 1]; - // @ts-ignore - currentObject[finalKey] = value; + _set(this.nodeConfig, key, value); return this; } diff --git a/src/package.json b/src/package.json index 4a83f561..155b96a7 100644 --- a/src/package.json +++ b/src/package.json @@ -53,6 +53,7 @@ "dependencies": { "@arbitrum/sdk": "^3.2.0", "@arbitrum/token-bridge-contracts": "^1.2.1", - "ethers": "^5.7.2" + "ethers": "^5.7.2", + "lodash.set": "^4.3.2" } } diff --git a/yarn.lock b/yarn.lock index f132f223..41a8e36f 100644 --- a/yarn.lock +++ b/yarn.lock @@ -760,6 +760,18 @@ resolved "https://registry.yarnpkg.com/@types/chai/-/chai-4.3.10.tgz#2ad2959d1767edee5b0e4efb1a0cd2b500747317" integrity sha512-of+ICnbqjmFCiixUnqRulbylyXQrPqIGf/B3Jax1wIF3DvSheysQxAWvqHhZiW3IQrycvokcLcFQlveGp+vyNg== +"@types/lodash.set@^4.3.9": + version "4.3.9" + resolved "https://registry.yarnpkg.com/@types/lodash.set/-/lodash.set-4.3.9.tgz#55d95bce407b42c6655f29b2d0811fd428e698f0" + integrity sha512-KOxyNkZpbaggVmqbpr82N2tDVTx05/3/j0f50Es1prxrWB0XYf9p3QNxqcbWb7P1Q9wlvsUSlCFnwlPCIJ46PQ== + dependencies: + "@types/lodash" "*" + +"@types/lodash@*": + version "4.17.0" + resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.17.0.tgz#d774355e41f372d5350a4d0714abb48194a489c3" + integrity sha512-t7dhREVv6dbNj0q17X12j7yDG4bD/DHYX7o5/DbDxobP0HnGPgpRz2Ej77aL7TZT3DSw13fqUTj8J4mMnqa7WA== + "@types/node@*", "@types/node@^20.9.0": version "20.9.0" resolved "https://registry.yarnpkg.com/@types/node/-/node-20.9.0.tgz#bfcdc230583aeb891cf51e73cfdaacdd8deae298" @@ -2189,6 +2201,11 @@ locate-path@^7.1.0: dependencies: p-locate "^6.0.0" +lodash.set@^4.3.2: + version "4.3.2" + resolved "https://registry.yarnpkg.com/lodash.set/-/lodash.set-4.3.2.tgz#d8757b1da807dde24816b0d6a84bea1a76230b23" + integrity sha512-4hNPN5jlm/N/HLMCO43v8BXKq9Z7QdAGc/VGrRD61w8gN9g/6jF9A4L1pbUgBLCffi0w9VsXfTOij5x8iTyFvg== + log-symbols@^5.1.0: version "5.1.0" resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-5.1.0.tgz#a20e3b9a5f53fac6aeb8e2bb22c07cf2c8f16d93" From 92749e36b569f624315903f171039a161ba75e95 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Tue, 19 Mar 2024 15:49:20 +0100 Subject: [PATCH 15/24] fix the initialized check --- src/nodeConfigBuilder.ts | 39 +++++++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 12 deletions(-) diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index 846361d4..a01ae7de 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -43,12 +43,18 @@ export type NodeConfigBuilderEnableDataAvailabilityServiceParams = { }; export class NodeConfigBuilder { + /** + * The underlying node config object being built. + */ private nodeConfig: NodeConfig; - private isInitialized: boolean; + /** + * Whether or not the builder was initialized with the necessary data. + */ + private initialized: boolean; constructor(initialNodeConfig?: NodeConfig) { this.nodeConfig = initialNodeConfig ?? {}; - this.isInitialized = false; + this.initialized = false; } private prepareChainInfoJson(params: InitializeThings): NodeConfigChainInfoJson { @@ -72,16 +78,25 @@ export class NodeConfigBuilder { ]; } + private privateSet( + key: TKey, + value: NodeConfigOptionGetType, + ): NodeConfigBuilder { + _set(this.nodeConfig, key, value); + + return this; + } + public initialize(params: InitializeThings): NodeConfigBuilder { const chainInfoJson = stringifyJson(this.prepareChainInfoJson(params)); - this.set('chain.name', params.chain.name); - this.set('chain.info-json', chainInfoJson); + this.privateSet('chain.name', params.chain.name); + this.privateSet('chain.info-json', chainInfoJson); - this.set('parent-chain.id', params.parentChain.id); - this.set('parent-chain.connection.url', params.parentChain.rpcUrl); + this.privateSet('parent-chain.id', params.parentChain.id); + this.privateSet('parent-chain.connection.url', params.parentChain.rpcUrl); - this.isInitialized = true; + this.initialized = true; return this; } @@ -146,15 +161,15 @@ export class NodeConfigBuilder { return this; } - set( + public set( key: TKey, value: NodeConfigOptionGetType, ): NodeConfigBuilder { - // if (!this.isInitialized) { - // throw new Error(`You must first call ".initialize()" on the builder`); - // } + if (!this.initialized) { + throw new Error(`You must first call ".initialize()" on the builder`); + } - _set(this.nodeConfig, key, value); + this.privateSet(key, value); return this; } From fb3746d1fca407ad714bd7e86f6fe90c9f524e64 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Tue, 19 Mar 2024 15:57:11 +0100 Subject: [PATCH 16/24] fix the stupid issue --- src/nodeConfigBuilder.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index a01ae7de..e70a02b6 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -53,7 +53,7 @@ export class NodeConfigBuilder { private initialized: boolean; constructor(initialNodeConfig?: NodeConfig) { - this.nodeConfig = initialNodeConfig ?? {}; + this.nodeConfig = { ...initialNodeConfig } ?? {}; this.initialized = false; } From 24b8de92592d93863afa9fbf5c513a417a48f3d3 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Tue, 19 Mar 2024 15:58:22 +0100 Subject: [PATCH 17/24] add comment --- src/nodeConfigBuilder.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index e70a02b6..a54fc3ea 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -53,6 +53,7 @@ export class NodeConfigBuilder { private initialized: boolean; constructor(initialNodeConfig?: NodeConfig) { + // it's necessary to do a spread operator here to make sure we create a copy of the object this.nodeConfig = { ...initialNodeConfig } ?? {}; this.initialized = false; } From 8edfcde96c6eea55ec3e836358d0d1e61007eeee Mon Sep 17 00:00:00 2001 From: spsjvc Date: Tue, 19 Mar 2024 16:36:35 +0100 Subject: [PATCH 18/24] fix --- src/nodeConfigBuilderUtils.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/nodeConfigBuilderUtils.ts b/src/nodeConfigBuilderUtils.ts index 6ef55c40..3cb6ee33 100644 --- a/src/nodeConfigBuilderUtils.ts +++ b/src/nodeConfigBuilderUtils.ts @@ -4,6 +4,7 @@ import { arbitrumOne, arbitrumNova, sepolia, + holesky, arbitrumSepolia, nitroTestnodeL1, nitroTestnodeL2, @@ -15,6 +16,7 @@ export function parentChainIsArbitrum(parentChainId: ParentChainId): boolean { switch (parentChainId) { case mainnet.id: case sepolia.id: + case holesky.id: case nitroTestnodeL1.id: return false; From 563c91ef4a9f34c45c63a2c7da2ba065922930fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dragi=C5=A1a=20Spasojevi=C4=87?= Date: Fri, 29 Mar 2024 10:47:49 +0100 Subject: [PATCH 19/24] reorganize --- src/types/NodeConfig.generated/index.ts | 2 ++ .../versions/NodeConfig.generated.v2.3.0-3e14543.ts} | 0 2 files changed, 2 insertions(+) create mode 100644 src/types/NodeConfig.generated/index.ts rename src/types/{NodeConfig.generated.ts => NodeConfig.generated/versions/NodeConfig.generated.v2.3.0-3e14543.ts} (100%) diff --git a/src/types/NodeConfig.generated/index.ts b/src/types/NodeConfig.generated/index.ts new file mode 100644 index 00000000..ac441fdd --- /dev/null +++ b/src/types/NodeConfig.generated/index.ts @@ -0,0 +1,2 @@ +// this file should always export the latest version +export * from './versions/NodeConfig.generated.v2.3.0-3e14543'; diff --git a/src/types/NodeConfig.generated.ts b/src/types/NodeConfig.generated/versions/NodeConfig.generated.v2.3.0-3e14543.ts similarity index 100% rename from src/types/NodeConfig.generated.ts rename to src/types/NodeConfig.generated/versions/NodeConfig.generated.v2.3.0-3e14543.ts From e967f2568cff1f1dcbe275c222dd926dc1e851c1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dragi=C5=A1a=20Spasojevi=C4=87?= Date: Fri, 29 Mar 2024 10:50:06 +0100 Subject: [PATCH 20/24] update where file is written --- package.json | 2 +- src/scripts/generateNodeConfigType.ts | 8 +++++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/package.json b/package.json index 7e3c7a92..1e06ae37 100644 --- a/package.json +++ b/package.json @@ -11,7 +11,7 @@ "dev": "yarn build --watch", "generate": "wagmi generate", "generate:node-config-type": "yarn build && node ./src/dist/scripts/generateNodeConfigType.js", - "postgenerate:node-config-type": "prettier --write ./src/types/NodeConfig.generated.ts", + "postgenerate:node-config-type": "prettier --write ./src/types/NodeConfig.generated", "test:unit": "vitest unit.test", "test:integration": "vitest integration.test", "postinstall": "patch-package", diff --git a/src/scripts/generateNodeConfigType.ts b/src/scripts/generateNodeConfigType.ts index 69a6bbc8..57a0e3e0 100644 --- a/src/scripts/generateNodeConfigType.ts +++ b/src/scripts/generateNodeConfigType.ts @@ -179,9 +179,11 @@ function main() { const cliOptionsNestedObject = createCliOptionsNestedObject(cliOptions); // create the new source file - const sourceFile = new Project().createSourceFile('./src/types/NodeConfig.generated.ts', '', { - overwrite: true, - }); + const sourceFile = new Project().createSourceFile( + `./src/types/NodeConfig.generated/versions/NodeConfig.generated.${nitroNodeTag}.ts`, + '', + { overwrite: true }, + ); // append header sourceFile.insertText(0, generateHeader()); // append NodeConfig type declaration From 0dca282193cf821323029c385dc81eacfd517f03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dragi=C5=A1a=20Spasojevi=C4=87?= Date: Fri, 29 Mar 2024 10:52:51 +0100 Subject: [PATCH 21/24] update naming schema --- src/scripts/generateNodeConfigType.ts | 2 +- src/types/NodeConfig.generated/index.ts | 2 +- ...NodeConfig.generated.v2.3.0-3e14543.ts => v2.3.0-3e14543.ts} | 0 3 files changed, 2 insertions(+), 2 deletions(-) rename src/types/NodeConfig.generated/versions/{NodeConfig.generated.v2.3.0-3e14543.ts => v2.3.0-3e14543.ts} (100%) diff --git a/src/scripts/generateNodeConfigType.ts b/src/scripts/generateNodeConfigType.ts index 57a0e3e0..23a8e59b 100644 --- a/src/scripts/generateNodeConfigType.ts +++ b/src/scripts/generateNodeConfigType.ts @@ -180,7 +180,7 @@ function main() { // create the new source file const sourceFile = new Project().createSourceFile( - `./src/types/NodeConfig.generated/versions/NodeConfig.generated.${nitroNodeTag}.ts`, + `./src/types/NodeConfig.generated/versions/${nitroNodeTag}.ts`, '', { overwrite: true }, ); diff --git a/src/types/NodeConfig.generated/index.ts b/src/types/NodeConfig.generated/index.ts index ac441fdd..23112d85 100644 --- a/src/types/NodeConfig.generated/index.ts +++ b/src/types/NodeConfig.generated/index.ts @@ -1,2 +1,2 @@ // this file should always export the latest version -export * from './versions/NodeConfig.generated.v2.3.0-3e14543'; +export * from './versions/v2.3.0-3e14543'; diff --git a/src/types/NodeConfig.generated/versions/NodeConfig.generated.v2.3.0-3e14543.ts b/src/types/NodeConfig.generated/versions/v2.3.0-3e14543.ts similarity index 100% rename from src/types/NodeConfig.generated/versions/NodeConfig.generated.v2.3.0-3e14543.ts rename to src/types/NodeConfig.generated/versions/v2.3.0-3e14543.ts From 275dc1de025aeeef6045f2d05ce5ca3a9d0110c5 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Thu, 6 Jun 2024 11:23:22 +0200 Subject: [PATCH 22/24] revert to old approach --- package.json | 2 +- src/scripts/generateNodeConfigType.ts | 8 +- src/types/NodeConfig.generated.ts | 2336 +++++++++++- src/types/NodeConfig.generated/index.ts | 2 - .../versions/v2.3.0-3e14543.ts | 3376 ----------------- 5 files changed, 2338 insertions(+), 3386 deletions(-) delete mode 100644 src/types/NodeConfig.generated/index.ts delete mode 100644 src/types/NodeConfig.generated/versions/v2.3.0-3e14543.ts diff --git a/package.json b/package.json index 1e06ae37..7e3c7a92 100644 --- a/package.json +++ b/package.json @@ -11,7 +11,7 @@ "dev": "yarn build --watch", "generate": "wagmi generate", "generate:node-config-type": "yarn build && node ./src/dist/scripts/generateNodeConfigType.js", - "postgenerate:node-config-type": "prettier --write ./src/types/NodeConfig.generated", + "postgenerate:node-config-type": "prettier --write ./src/types/NodeConfig.generated.ts", "test:unit": "vitest unit.test", "test:integration": "vitest integration.test", "postinstall": "patch-package", diff --git a/src/scripts/generateNodeConfigType.ts b/src/scripts/generateNodeConfigType.ts index 1c965f72..79a3c351 100644 --- a/src/scripts/generateNodeConfigType.ts +++ b/src/scripts/generateNodeConfigType.ts @@ -179,11 +179,9 @@ function main() { const cliOptionsNestedObject = createCliOptionsNestedObject(cliOptions); // create the new source file - const sourceFile = new Project().createSourceFile( - `./src/types/NodeConfig.generated/versions/${nitroNodeTag}.ts`, - '', - { overwrite: true }, - ); + const sourceFile = new Project().createSourceFile('./src/types/NodeConfig.generated.ts', '', { + overwrite: true, + }); // append header sourceFile.insertText(0, generateHeader()); // append NodeConfig type declaration diff --git a/src/types/NodeConfig.generated.ts b/src/types/NodeConfig.generated.ts index e3d1835b..e6b18e03 100644 --- a/src/types/NodeConfig.generated.ts +++ b/src/types/NodeConfig.generated.ts @@ -3,10 +3,10 @@ // THIS FILE IS AUTOMATICALLY GENERATED AND SHOULD NOT BE EDITED MANUALLY // // IMAGE: offchainlabs/nitro-node:v2.3.3-6a1c1a7 -// TIMESTAMP: 2024-04-18T09:36:12.267Z +// TIMESTAMP: 2024-06-06T09:22:38.394Z // // --- -/** Nitro node configuration options */ +/** Nitro node configuration object */ export type NodeConfig = { 'auth'?: { /** AUTH-RPC server listening interface (default "127.0.0.1") */ @@ -1119,3 +1119,2335 @@ export type NodeConfig = { 'rpcprefix'?: string; }; }; +/** Union type for all Nitro node configuration options */ +export type NodeConfigOption = + | { + /** AUTH-RPC server listening interface (default "127.0.0.1") */ + key: 'auth.addr'; + type: string; + } + | { + /** APIs offered over the AUTH-RPC interface (default [validation]) */ + key: 'auth.api'; + type: string[]; + } + | { + /** Path to file holding JWT secret (32B hex) */ + key: 'auth.jwtsecret'; + type: string; + } + | { + /** Origins from which to accept AUTH requests (default [localhost]) */ + key: 'auth.origins'; + type: string[]; + } + | { + /** AUTH-RPC server listening port (default 8549) */ + key: 'auth.port'; + type: number; + } + | { + /** minimum number of blocks to execute per thread. When mode is random this acts as the size of random block range sample (default 10000) */ + key: 'blocks-reexecutor.blocks-per-thread'; + type: number; + } + | { + /** enables re-execution of a range of blocks against historic state */ + key: 'blocks-reexecutor.enable'; + type: boolean; + } + | { + /** last block number of the block range for re-execution */ + key: 'blocks-reexecutor.end-block'; + type: number; + } + | { + /** mode to run the blocks-reexecutor on. Valid modes full and random. full - execute all the blocks in the given range. random - execute a random sample range of blocks with in a given range (default "random") */ + key: 'blocks-reexecutor.mode'; + type: string; + } + | { + /** number of threads to parallelize blocks re-execution (default 12) */ + key: 'blocks-reexecutor.room'; + type: number; + } + | { + /** first block number of the block range for re-execution */ + key: 'blocks-reexecutor.start-block'; + type: number; + } + | { + /** account to use (default is first account in keystore) */ + key: 'chain.dev-wallet.account'; + type: string; + } + | { + /** if true, creates new key then exits */ + key: 'chain.dev-wallet.only-create-key'; + type: boolean; + } + | { + /** wallet passphrase (default "PASSWORD_NOT_SET") */ + key: 'chain.dev-wallet.password'; + type: string; + } + | { + /** pathname for wallet */ + key: 'chain.dev-wallet.pathname'; + type: string; + } + | { + /** private key for wallet */ + key: 'chain.dev-wallet.private-key'; + type: string; + } + | { + /** L2 chain ID (determines Arbitrum network) */ + key: 'chain.id'; + type: number; + } + | { + /** L2 chain info json files */ + key: 'chain.info-files'; + type: string[]; + } + | { + /** path to save temp downloaded file (default "/tmp/") */ + key: 'chain.info-ipfs-download-path'; + type: string; + } + | { + /** url to download chain info file */ + key: 'chain.info-ipfs-url'; + type: string; + } + | { + /** L2 chain info in json string format */ + key: 'chain.info-json'; + type: string; + } + | { + /** L2 chain name (determines Arbitrum network) */ + key: 'chain.name'; + type: string; + } + | { + /** print out currently active configuration file */ + key: 'conf.dump'; + type: boolean; + } + | { + /** environment variables with given prefix will be loaded as configuration values */ + key: 'conf.env-prefix'; + type: string; + } + | { + /** name of configuration file */ + key: 'conf.file'; + type: string[]; + } + | { + /** how often to reload configuration (0=disable periodic reloading) */ + key: 'conf.reload-interval'; + type: string; + } + | { + /** S3 access key */ + key: 'conf.s3.access-key'; + type: string; + } + | { + /** S3 bucket */ + key: 'conf.s3.bucket'; + type: string; + } + | { + /** S3 object key */ + key: 'conf.s3.object-key'; + type: string; + } + | { + /** S3 region */ + key: 'conf.s3.region'; + type: string; + } + | { + /** S3 secret key */ + key: 'conf.s3.secret-key'; + type: string; + } + | { + /** configuration as JSON string */ + key: 'conf.string'; + type: string; + } + | { + /** retain past block state */ + key: 'execution.caching.archive'; + type: boolean; + } + | { + /** minimum age of recent blocks to keep in memory (default 30m0s) */ + key: 'execution.caching.block-age'; + type: string; + } + | { + /** minimum number of recent blocks to keep in memory (default 128) */ + key: 'execution.caching.block-count'; + type: number; + } + | { + /** amount of memory in megabytes to cache database contents with (default 2048) */ + key: 'execution.caching.database-cache'; + type: number; + } + | { + /** maximum amount of gas in blocks to skip saving state to Persistent storage (archive node only) -- warning: this option seems to cause issues */ + key: 'execution.caching.max-amount-of-gas-to-skip-state-saving'; + type: number; + } + | { + /** maximum number of blocks to skip state saving to persistent storage (archive node only) -- warning: this option seems to cause issues */ + key: 'execution.caching.max-number-of-blocks-to-skip-state-saving'; + type: number; + } + | { + /** amount of memory in megabytes to cache state snapshots with (default 400) */ + key: 'execution.caching.snapshot-cache'; + type: number; + } + | { + /** maximum gas rolled back to recover snapshot (default 300000000000) */ + key: 'execution.caching.snapshot-restore-gas-limit'; + type: number; + } + | { + /** amount of memory in megabytes to cache unchanged state trie nodes with (default 600) */ + key: 'execution.caching.trie-clean-cache'; + type: number; + } + | { + /** amount of memory in megabytes to cache state diffs against disk with (larger cache lowers database growth) (default 1024) */ + key: 'execution.caching.trie-dirty-cache'; + type: number; + } + | { + /** maximum block processing time before trie is written to hard-disk (default 1h0m0s) */ + key: 'execution.caching.trie-time-limit'; + type: string; + } + | { + /** DANGEROUS! forces a reorg to an old block height. To be used for testing only. -1 to disable (default -1) */ + key: 'execution.dangerous.reorg-to-block'; + type: number; + } + | { + /** enable prefetching of blocks (default true) */ + key: 'execution.enable-prefetch-block'; + type: boolean; + } + | { + /** total time to wait before cancelling connection (default 30s) */ + key: 'execution.forwarder.connection-timeout'; + type: string; + } + | { + /** time until idle connections are closed (default 15s) */ + key: 'execution.forwarder.idle-connection-timeout'; + type: string; + } + | { + /** maximum number of idle connections to keep open (default 1) */ + key: 'execution.forwarder.max-idle-connections'; + type: number; + } + | { + /** the Redis URL to recomend target via */ + key: 'execution.forwarder.redis-url'; + type: string; + } + | { + /** minimal time between update retries (default 100ms) */ + key: 'execution.forwarder.retry-interval'; + type: string; + } + | { + /** forwarding target update interval (default 1s) */ + key: 'execution.forwarder.update-interval'; + type: string; + } + | { + /** transaction forwarding target URL, or "null" to disable forwarding (iff not sequencer) */ + key: 'execution.forwarding-target'; + type: string; + } + | { + /** Dangerous! only meant to be used by system tests */ + key: 'execution.parent-chain-reader.dangerous.wait-for-tx-approval-safe-poll'; + type: string; + } + | { + /** enable reader connection (default true) */ + key: 'execution.parent-chain-reader.enable'; + type: boolean; + } + | { + /** warns if the latest l1 block is at least this old (default 5m0s) */ + key: 'execution.parent-chain-reader.old-header-timeout'; + type: string; + } + | { + /** interval when polling endpoint (default 15s) */ + key: 'execution.parent-chain-reader.poll-interval'; + type: string; + } + | { + /** do not attempt to subscribe to header events */ + key: 'execution.parent-chain-reader.poll-only'; + type: boolean; + } + | { + /** interval for subscribe error (default 5m0s) */ + key: 'execution.parent-chain-reader.subscribe-err-interval'; + type: string; + } + | { + /** timeout when waiting for a transaction (default 5m0s) */ + key: 'execution.parent-chain-reader.tx-timeout'; + type: string; + } + | { + /** use l1 data about finalized/safe blocks (default true) */ + key: 'execution.parent-chain-reader.use-finality-data'; + type: boolean; + } + | { + /** like trie-clean-cache for the separate, recording database (used for validation) (default 16) */ + key: 'execution.recording-database.trie-clean-cache'; + type: number; + } + | { + /** like trie-dirty-cache for the separate, recording database (used for validation) (default 1024) */ + key: 'execution.recording-database.trie-dirty-cache'; + type: number; + } + | { + /** list of whitelisted rpc methods */ + key: 'execution.rpc.allow-method'; + type: string[]; + } + | { + /** bounds the number of blocks arbdebug calls may return (default 256) */ + key: 'execution.rpc.arbdebug.block-range-bound'; + type: number; + } + | { + /** bounds the length of timeout queues arbdebug calls may return (default 512) */ + key: 'execution.rpc.arbdebug.timeout-queue-bound'; + type: number; + } + | { + /** number of blocks a single bloom bit section vector holds (default 16384) */ + key: 'execution.rpc.bloom-bits-blocks'; + type: number; + } + | { + /** number of confirmation blocks before a bloom section is considered final (default 256) */ + key: 'execution.rpc.bloom-confirms'; + type: number; + } + | { + /** url to redirect classic requests, use "error:[CODE:]MESSAGE" to return specified error instead of redirecting */ + key: 'execution.rpc.classic-redirect'; + type: string; + } + | { + /** timeout for forwarded classic requests, where 0 = no timeout */ + key: 'execution.rpc.classic-redirect-timeout'; + type: string; + } + | { + /** timeout used for eth_call (0=infinite) (default 5s) */ + key: 'execution.rpc.evm-timeout'; + type: string; + } + | { + /** max number of blocks a fee history request may cover (default 1024) */ + key: 'execution.rpc.feehistory-max-block-count'; + type: number; + } + | { + /** log filter system maximum number of cached blocks (default 32) */ + key: 'execution.rpc.filter-log-cache-size'; + type: number; + } + | { + /** log filter system maximum time filters stay active (default 5m0s) */ + key: 'execution.rpc.filter-timeout'; + type: string; + } + | { + /** cap on computation gas that can be used in eth_call/estimateGas (0=infinite) (default 50000000) */ + key: 'execution.rpc.gas-cap'; + type: number; + } + | { + /** maximum depth for recreating state, measured in l2 gas (0=don't recreate state, -1=infinite, -2=use default value for archive or non-archive node (whichever is configured)) (default -2) */ + key: 'execution.rpc.max-recreate-state-depth'; + type: number; + } + | { + /** allow transactions that aren't EIP-155 replay protected to be submitted over the RPC (default true) */ + key: 'execution.rpc.tx-allow-unprotected'; + type: boolean; + } + | { + /** cap on transaction fee (in ether) that can be sent via the RPC APIs (0 = no cap) (default 1) */ + key: 'execution.rpc.tx-fee-cap'; + type: number; + } + | { + /** secondary transaction forwarding target URL */ + key: 'execution.secondary-forwarding-target'; + type: string[]; + } + | { + /** act and post to l1 as sequencer */ + key: 'execution.sequencer.enable'; + type: boolean; + } + | { + /** total time to wait before cancelling connection (default 30s) */ + key: 'execution.sequencer.forwarder.connection-timeout'; + type: string; + } + | { + /** time until idle connections are closed (default 1m0s) */ + key: 'execution.sequencer.forwarder.idle-connection-timeout'; + type: string; + } + | { + /** maximum number of idle connections to keep open (default 100) */ + key: 'execution.sequencer.forwarder.max-idle-connections'; + type: number; + } + | { + /** the Redis URL to recomend target via */ + key: 'execution.sequencer.forwarder.redis-url'; + type: string; + } + | { + /** minimal time between update retries (default 100ms) */ + key: 'execution.sequencer.forwarder.retry-interval'; + type: string; + } + | { + /** forwarding target update interval (default 1s) */ + key: 'execution.sequencer.forwarder.update-interval'; + type: string; + } + | { + /** maximum acceptable time difference between the local time and the latest L1 block's timestamp (default 1h0m0s) */ + key: 'execution.sequencer.max-acceptable-timestamp-delta'; + type: string; + } + | { + /** minimum delay between blocks (sets a maximum speed of block production) (default 250ms) */ + key: 'execution.sequencer.max-block-speed'; + type: string; + } + | { + /** maximum gas executed in a revert for the sequencer to reject the transaction instead of posting it (anti-DOS) (default 31000) */ + key: 'execution.sequencer.max-revert-gas-reject'; + type: number; + } + | { + /** maximum transaction size the sequencer will accept (default 95000) */ + key: 'execution.sequencer.max-tx-data-size'; + type: number; + } + | { + /** size of the tx sender nonce cache (default 1024) */ + key: 'execution.sequencer.nonce-cache-size'; + type: number; + } + | { + /** maximum amount of time to wait for a predecessor before rejecting a tx with nonce too high (default 1s) */ + key: 'execution.sequencer.nonce-failure-cache-expiry'; + type: string; + } + | { + /** number of transactions with too high of a nonce to keep in memory while waiting for their predecessor (default 1024) */ + key: 'execution.sequencer.nonce-failure-cache-size'; + type: number; + } + | { + /** size of the pending tx queue (default 1024) */ + key: 'execution.sequencer.queue-size'; + type: number; + } + | { + /** maximum amount of time transaction can wait in queue (default 12s) */ + key: 'execution.sequencer.queue-timeout'; + type: string; + } + | { + /** comma separated whitelist of authorized senders (if empty, everyone is allowed) */ + key: 'execution.sequencer.sender-whitelist'; + type: string; + } + | { + /** retain the ability to lookup transactions by hash for the past N blocks (0 = all blocks) (default 126230400) */ + key: 'execution.tx-lookup-limit'; + type: number; + } + | { + /** how long ago should the storage conditions from eth_SendRawTransactionConditional be true, 0 = don't check old state (default 2) */ + key: 'execution.tx-pre-checker.required-state-age'; + type: number; + } + | { + /** maximum number of blocks to look back while looking for the seconds old state, 0 = don't limit the search (default 4) */ + key: 'execution.tx-pre-checker.required-state-max-blocks'; + type: number; + } + | { + /** how strict to be when checking txs before forwarding them. 0 = accept anything, 10 = should never reject anything that'd succeed, 20 = likely won't reject anything that'd succeed, 30 = full validation which may reject txs that would succeed */ + key: 'execution.tx-pre-checker.strictness'; + type: number; + } + | { + /** size of intermediate log records buffer (default 512) */ + key: 'file-logging.buf-size'; + type: number; + } + | { + /** enable compression of old log files (default true) */ + key: 'file-logging.compress'; + type: boolean; + } + | { + /** enable logging to file (default true) */ + key: 'file-logging.enable'; + type: boolean; + } + | { + /** path to log file (default "nitro.log") */ + key: 'file-logging.file'; + type: string; + } + | { + /** if true: local time will be used in old log filename timestamps */ + key: 'file-logging.local-time'; + type: boolean; + } + | { + /** maximum number of days to retain old log files based on the timestamp encoded in their filename (0 = no limit) */ + key: 'file-logging.max-age'; + type: number; + } + | { + /** maximum number of old log files to retain (0 = no limit) (default 20) */ + key: 'file-logging.max-backups'; + type: number; + } + | { + /** log file size in Mb that will trigger log file rotation (0 = trigger disabled) (default 5) */ + key: 'file-logging.max-size'; + type: number; + } + | { + /** Comma separated list of domains from which to accept cross origin requests (browser enforced) */ + key: 'graphql.corsdomain'; + type: string[]; + } + | { + /** Enable graphql endpoint on the rpc endpoint */ + key: 'graphql.enable'; + type: boolean; + } + | { + /** Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard (default [localhost]) */ + key: 'graphql.vhosts'; + type: string[]; + } + | { + /** HTTP-RPC server listening interface */ + key: 'http.addr'; + type: string; + } + | { + /** APIs offered over the HTTP-RPC interface (default [net,web3,eth,arb]) */ + key: 'http.api'; + type: string[]; + } + | { + /** Comma separated list of domains from which to accept cross origin requests (browser enforced) */ + key: 'http.corsdomain'; + type: string[]; + } + | { + /** HTTP-RPC server listening port (default 8547) */ + key: 'http.port'; + type: number; + } + | { + /** HTTP path path prefix on which JSON-RPC is served. Use '/' to serve on all paths */ + key: 'http.rpcprefix'; + type: string; + } + | { + /** the maximum amount of time to wait for the next request when keep-alives are enabled (http.Server.IdleTimeout) (default 2m0s) */ + key: 'http.server-timeouts.idle-timeout'; + type: string; + } + | { + /** the amount of time allowed to read the request headers (http.Server.ReadHeaderTimeout) (default 30s) */ + key: 'http.server-timeouts.read-header-timeout'; + type: string; + } + | { + /** the maximum duration for reading the entire request (http.Server.ReadTimeout) (default 30s) */ + key: 'http.server-timeouts.read-timeout'; + type: string; + } + | { + /** the maximum duration before timing out writes of the response (http.Server.WriteTimeout) (default 30s) */ + key: 'http.server-timeouts.write-timeout'; + type: string; + } + | { + /** Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard (default [localhost]) */ + key: 'http.vhosts'; + type: string[]; + } + | { + /** during init - sync database every X accounts. Lower value for low-memory systems. 0 disables. (default 100000) */ + key: 'init.accounts-per-sync'; + type: number; + } + | { + /** init with dev data (1 account with balance) instead of file import */ + key: 'init.dev-init'; + type: boolean; + } + | { + /** Address of dev-account. Leave empty to use the dev-wallet. */ + key: 'init.dev-init-address'; + type: string; + } + | { + /** Number of preinit blocks. Must exist in ancient database. */ + key: 'init.dev-init-blocknum'; + type: number; + } + | { + /** path to save temp downloaded file (default "/tmp/") */ + key: 'init.download-path'; + type: string; + } + | { + /** how long to wait between polling attempts (default 1m0s) */ + key: 'init.download-poll'; + type: string; + } + | { + /** init with empty state */ + key: 'init.empty'; + type: boolean; + } + | { + /** if true: in case database exists init code will be reexecuted and genesis block compared to database */ + key: 'init.force'; + type: boolean; + } + | { + /** path for json data to import */ + key: 'init.import-file'; + type: string; + } + | { + /** pruning for a given use: "full" for full nodes serving RPC requests, or "validator" for validators */ + key: 'init.prune'; + type: string; + } + | { + /** the amount of memory in megabytes to use for the pruning bloom filter (higher values prune better) (default 2048) */ + key: 'init.prune-bloom-size'; + type: number; + } + | { + /** block number to start recreating missing states from (0 = disabled) */ + key: 'init.recreate-missing-state-from'; + type: number; + } + | { + /** forces a reset to an old message height. Also set max-reorg-resequence-depth=0 to force re-reading messages (default -1) */ + key: 'init.reset-to-message'; + type: number; + } + | { + /** quit after init is done */ + key: 'init.then-quit'; + type: boolean; + } + | { + /** url to download initializtion data - will poll if download fails */ + key: 'init.url'; + type: string; + } + | { + /** Requested location to place the IPC endpoint. An empty path disables IPC. */ + key: 'ipc.path'; + type: string; + } + | { + /** log level (default 3) */ + key: 'log-level'; + type: number; + } + | { + /** log type (plaintext or json) (default "plaintext") */ + key: 'log-type'; + type: string; + } + | { + /** enable metrics */ + key: 'metrics'; + type: boolean; + } + | { + /** metrics server address (default "127.0.0.1") */ + key: 'metrics-server.addr'; + type: string; + } + | { + /** metrics server port (default 6070) */ + key: 'metrics-server.port'; + type: number; + } + | { + /** metrics server update interval (default 3s) */ + key: 'metrics-server.update-interval'; + type: string; + } + | { + /** batch compression level (default 11) */ + key: 'node.batch-poster.compression-level'; + type: number; + } + | { + /** In AnyTrust mode, the period which DASes are requested to retain the stored batches. (default 360h0m0s) */ + key: 'node.batch-poster.das-retention-period'; + type: string; + } + | { + /** if true, don't put transactions in the mempool that spend a total greater than the batch poster's balance (default true) */ + key: 'node.batch-poster.data-poster.allocate-mempool-balance'; + type: boolean; + } + | { + /** comma-separated list of durations since first posting a blob transaction to attempt a replace-by-fee (default "5m,10m,30m,1h,4h,8h,16h,22h") */ + key: 'node.batch-poster.data-poster.blob-tx-replacement-times'; + type: string; + } + | { + /** clear database storage */ + key: 'node.batch-poster.data-poster.dangerous.clear-dbstorage'; + type: boolean; + } + | { + /** unit to measure the time elapsed since creation of transaction used for maximum fee cap calculation (default 10m0s) */ + key: 'node.batch-poster.data-poster.elapsed-time-base'; + type: string; + } + | { + /** weight given to the units of time elapsed used for maximum fee cap calculation (default 10) */ + key: 'node.batch-poster.data-poster.elapsed-time-importance'; + type: number; + } + | { + /** external signer address */ + key: 'node.batch-poster.data-poster.external-signer.address'; + type: string; + } + | { + /** rpc client cert */ + key: 'node.batch-poster.data-poster.external-signer.client-cert'; + type: string; + } + | { + /** rpc client private key */ + key: 'node.batch-poster.data-poster.external-signer.client-private-key'; + type: string; + } + | { + /** external signer method (default "eth_signTransaction") */ + key: 'node.batch-poster.data-poster.external-signer.method'; + type: string; + } + | { + /** external signer root CA */ + key: 'node.batch-poster.data-poster.external-signer.root-ca'; + type: string; + } + | { + /** external signer url */ + key: 'node.batch-poster.data-poster.external-signer.url'; + type: string; + } + | { + /** encodes items in a legacy way (as it was before dropping generics) */ + key: 'node.batch-poster.data-poster.legacy-storage-encoding'; + type: boolean; + } + | { + /** the maximum tip cap to post EIP-4844 blob carrying transactions at (default 1) */ + key: 'node.batch-poster.data-poster.max-blob-tx-tip-cap-gwei'; + type: number; + } + | { + /** the maximum multiple of the current price to bid for a transaction's fees (may be exceeded due to min rbf increase, 0 = unlimited) (default 100000) */ + key: 'node.batch-poster.data-poster.max-fee-bid-multiple-bips'; + type: number; + } + | { + /** mathematical formula to calculate maximum fee cap gwei the result of which would be float64. This expression is expected to be evaluated please refer https://github.com/Knetic/govaluate/blob/master/MANUAL.md to find all available mathematical operators. Currently available variables to construct the formula are BacklogOfBatches, UrgencyGWei, ElapsedTime, ElapsedTimeBase, ElapsedTimeImportance, and TargetPriceGWei (default "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei") */ + key: 'node.batch-poster.data-poster.max-fee-cap-formula'; + type: string; + } + | { + /** the maximum number of transactions to have queued in the mempool at once (0 = unlimited) (default 18) */ + key: 'node.batch-poster.data-poster.max-mempool-transactions'; + type: number; + } + | { + /** the maximum number of weight (weight = min(1, tx.blobs)) to have queued in the mempool at once (0 = unlimited) (default 18) */ + key: 'node.batch-poster.data-poster.max-mempool-weight'; + type: number; + } + | { + /** the maximum number of unconfirmed transactions to track at once (0 = unlimited) */ + key: 'node.batch-poster.data-poster.max-queued-transactions'; + type: number; + } + | { + /** the maximum tip cap to post transactions at (default 5) */ + key: 'node.batch-poster.data-poster.max-tip-cap-gwei'; + type: number; + } + | { + /** the minimum tip cap to post EIP-4844 blob carrying transactions at (default 1) */ + key: 'node.batch-poster.data-poster.min-blob-tx-tip-cap-gwei'; + type: number; + } + | { + /** the minimum tip cap to post transactions at (default 0.05) */ + key: 'node.batch-poster.data-poster.min-tip-cap-gwei'; + type: number; + } + | { + /** the maximum probable reorg depth, used to determine when a transaction will no longer likely need replaced-by-fee (default 1) */ + key: 'node.batch-poster.data-poster.nonce-rbf-soft-confs'; + type: number; + } + | { + /** disable message signature verification */ + key: 'node.batch-poster.data-poster.redis-signer.dangerous.disable-signature-verification'; + type: boolean; + } + | { + /** a fallback key used for message verification */ + key: 'node.batch-poster.data-poster.redis-signer.fallback-verification-key'; + type: string; + } + | { + /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ + key: 'node.batch-poster.data-poster.redis-signer.signing-key'; + type: string; + } + | { + /** comma-separated list of durations since first posting to attempt a replace-by-fee (default "5m,10m,20m,30m,1h,2h,4h,6h,8h,12h,16h,18h,20h,22h") */ + key: 'node.batch-poster.data-poster.replacement-times'; + type: string; + } + | { + /** the target price to use for maximum fee cap calculation (default 60) */ + key: 'node.batch-poster.data-poster.target-price-gwei'; + type: number; + } + | { + /** the urgency to use for maximum fee cap calculation (default 2) */ + key: 'node.batch-poster.data-poster.urgency-gwei'; + type: number; + } + | { + /** uses database storage when enabled (default true) */ + key: 'node.batch-poster.data-poster.use-db-storage'; + type: boolean; + } + | { + /** uses noop storage, it doesn't store anything */ + key: 'node.batch-poster.data-poster.use-noop-storage'; + type: boolean; + } + | { + /** only treat a transaction as confirmed after L1 finality has been achieved (recommended) (default true) */ + key: 'node.batch-poster.data-poster.wait-for-l1-finality'; + type: boolean; + } + | { + /** If unable to batch to DAS, disable fallback storing data on chain */ + key: 'node.batch-poster.disable-das-fallback-store-data-on-chain'; + type: boolean; + } + | { + /** enable posting batches to l1 */ + key: 'node.batch-poster.enable'; + type: boolean; + } + | { + /** how long to delay after error posting batch (default 10s) */ + key: 'node.batch-poster.error-delay'; + type: string; + } + | { + /** use this much more gas than estimation says is necessary to post batches (default 50000) */ + key: 'node.batch-poster.extra-batch-gas'; + type: number; + } + | { + /** for gas estimation, use this multiple of the basefee (measured in basis points) as the max fee per gas (default 15000) */ + key: 'node.batch-poster.gas-estimate-base-fee-multiple-bips'; + type: number; + } + | { + /** The gas refunder contract address (optional) */ + key: 'node.batch-poster.gas-refunder-address'; + type: string; + } + | { + /** if the parent chain supports 4844 blobs and ignore-blob-price is true, post 4844 blobs even if it's not price efficient */ + key: 'node.batch-poster.ignore-blob-price'; + type: boolean; + } + | { + /** only post messages to batches when they're within the max future block/timestamp as of this L1 block tag ("safe", "finalized", "latest", or "ignore" to ignore this check) */ + key: 'node.batch-poster.l1-block-bound'; + type: string; + } + | { + /** post batches even if not within the layer 1 future bounds if we're within this margin of the max delay (default 1h0m0s) */ + key: 'node.batch-poster.l1-block-bound-bypass'; + type: string; + } + | { + /** maximum 4844 blob enabled batch size (default 779288) */ + key: 'node.batch-poster.max-4844-batch-size'; + type: number; + } + | { + /** maximum batch posting delay (default 1h0m0s) */ + key: 'node.batch-poster.max-delay'; + type: string; + } + | { + /** maximum batch size (default 100000) */ + key: 'node.batch-poster.max-size'; + type: number; + } + | { + /** account to use (default is first account in keystore) */ + key: 'node.batch-poster.parent-chain-wallet.account'; + type: string; + } + | { + /** if true, creates new key then exits */ + key: 'node.batch-poster.parent-chain-wallet.only-create-key'; + type: boolean; + } + | { + /** wallet passphrase (default "PASSWORD_NOT_SET") */ + key: 'node.batch-poster.parent-chain-wallet.password'; + type: string; + } + | { + /** pathname for wallet (default "batch-poster-wallet") */ + key: 'node.batch-poster.parent-chain-wallet.pathname'; + type: string; + } + | { + /** private key for wallet */ + key: 'node.batch-poster.parent-chain-wallet.private-key'; + type: string; + } + | { + /** how long to wait after no batches are ready to be posted before checking again (default 10s) */ + key: 'node.batch-poster.poll-interval'; + type: string; + } + | { + /** if the parent chain supports 4844 blobs and they're well priced, post EIP-4844 blobs */ + key: 'node.batch-poster.post-4844-blobs'; + type: boolean; + } + | { + /** should node always try grabing lock in background */ + key: 'node.batch-poster.redis-lock.background-lock'; + type: boolean; + } + | { + /** if false, always treat this as locked and don't write the lock to redis (default true) */ + key: 'node.batch-poster.redis-lock.enable'; + type: boolean; + } + | { + /** key for lock */ + key: 'node.batch-poster.redis-lock.key'; + type: string; + } + | { + /** how long lock is held (default 1m0s) */ + key: 'node.batch-poster.redis-lock.lockout-duration'; + type: string; + } + | { + /** this node's id prefix when acquiring the lock (optional) */ + key: 'node.batch-poster.redis-lock.my-id'; + type: string; + } + | { + /** how long between consecutive calls to redis (default 10s) */ + key: 'node.batch-poster.redis-lock.refresh-duration'; + type: string; + } + | { + /** if non-empty, the Redis URL to store queued transactions in */ + key: 'node.batch-poster.redis-url'; + type: string; + } + | { + /** post batches with access lists to reduce gas usage (disabled for L3s) (default true) */ + key: 'node.batch-poster.use-access-lists'; + type: boolean; + } + | { + /** wait for the max batch delay, even if the batch is full */ + key: 'node.batch-poster.wait-for-max-delay'; + type: boolean; + } + | { + /** current wasm module root ('current' read from chain, 'latest' from machines/latest dir, or provide hash) (default "current") */ + key: 'node.block-validator.current-module-root'; + type: string; + } + | { + /** resets block-by-block validation, starting again at genesis */ + key: 'node.block-validator.dangerous.reset-block-validation'; + type: boolean; + } + | { + /** enable block-by-block validation */ + key: 'node.block-validator.enable'; + type: boolean; + } + | { + /** failing a validation is treated as a fatal error (default true) */ + key: 'node.block-validator.failure-is-fatal'; + type: boolean; + } + | { + /** prepare entries for up to that many blocks ahead of validation (small footprint) (default 1024) */ + key: 'node.block-validator.forward-blocks'; + type: number; + } + | { + /** minimum free-memory limit after reaching which the blockvalidator pauses validation. Enabled by default as 1GB, to disable provide empty string (default "default") */ + key: 'node.block-validator.memory-free-limit'; + type: string; + } + | { + /** pending upgrade wasm module root to additionally validate (hash, 'latest' or empty) (default "latest") */ + key: 'node.block-validator.pending-upgrade-module-root'; + type: string; + } + | { + /** record that many blocks ahead of validation (larger footprint) (default 24) */ + key: 'node.block-validator.prerecorded-blocks'; + type: number; + } + | { + /** poll time to check validations (default 1s) */ + key: 'node.block-validator.validation-poll'; + type: string; + } + | { + /** array of validation rpc configs given as a json string. time duration should be supplied in number indicating nanoseconds (default "default") */ + key: 'node.block-validator.validation-server-configs-list'; + type: string; + } + | { + /** limit size of arguments in log entries (default 2048) */ + key: 'node.block-validator.validation-server.arg-log-limit'; + type: number; + } + | { + /** how long to wait for initial connection */ + key: 'node.block-validator.validation-server.connection-wait'; + type: string; + } + | { + /** path to file with jwtsecret for validation - ignored if url is self or self-auth */ + key: 'node.block-validator.validation-server.jwtsecret'; + type: string; + } + | { + /** number of retries in case of failure(0 mean one attempt) (default 3) */ + key: 'node.block-validator.validation-server.retries'; + type: number; + } + | { + /** delay between retries */ + key: 'node.block-validator.validation-server.retry-delay'; + type: string; + } + | { + /** Errors matching this regular expression are automatically retried (default "websocket: close.*|dial tcp .*|.*i/o timeout|.*connection reset by peer|.*connection refused") */ + key: 'node.block-validator.validation-server.retry-errors'; + type: string; + } + | { + /** per-response timeout (0-disabled) */ + key: 'node.block-validator.validation-server.timeout'; + type: string; + } + | { + /** url of server, use self for loopback websocket, self-auth for loopback with authentication (default "self-auth") */ + key: 'node.block-validator.validation-server.url'; + type: string; + } + | { + /** DANGEROUS! disables the EIP-4844 blob reader, which is necessary to read batches */ + key: 'node.dangerous.disable-blob-reader'; + type: boolean; + } + | { + /** DANGEROUS! disables listening to L1. To be used in test nodes only */ + key: 'node.dangerous.no-l1-listener'; + type: boolean; + } + | { + /** DANGEROUS! allows sequencing without sequencer-coordinator */ + key: 'node.dangerous.no-sequencer-coordinator'; + type: boolean; + } + | { + /** enable Anytrust Data Availability mode */ + key: 'node.data-availability.enable'; + type: boolean; + } + | { + /** enable storage/retrieval of sequencer batch data from IPFS */ + key: 'node.data-availability.ipfs-storage.enable'; + type: boolean; + } + | { + /** list of IPFS peers to connect to, eg /ip4/1.2.3.4/tcp/12345/p2p/abc...xyz */ + key: 'node.data-availability.ipfs-storage.peers'; + type: string[]; + } + | { + /** pin sequencer batch data in IPFS (default true) */ + key: 'node.data-availability.ipfs-storage.pin-after-get'; + type: boolean; + } + | { + /** percent of sequencer batch data to pin, as a floating point number in the range 0.0 to 100.0 (default 100) */ + key: 'node.data-availability.ipfs-storage.pin-percentage'; + type: number; + } + | { + /** comma separated list of IPFS profiles to use, see https://docs.ipfs.tech/how-to/default-profile */ + key: 'node.data-availability.ipfs-storage.profiles'; + type: string; + } + | { + /** timeout for IPFS reads, since by default it will wait forever. Treat timeout as not found (default 1m0s) */ + key: 'node.data-availability.ipfs-storage.read-timeout'; + type: string; + } + | { + /** directory to use to store the local IPFS repo */ + key: 'node.data-availability.ipfs-storage.repo-dir'; + type: string; + } + | { + /** whether the Data Availability Service should fail immediately on errors (not recommended) */ + key: 'node.data-availability.panic-on-error'; + type: boolean; + } + | { + /** parent chain RPC connection attempts (spaced out at least 1 second per attempt, 0 to retry infinitely), only used in standalone daserver; when running as part of a node that node's parent chain configuration is used (default 15) */ + key: 'node.data-availability.parent-chain-connection-attempts'; + type: number; + } + | { + /** URL for parent chain node, only used in standalone daserver; when running as part of a node that node's L1 configuration is used */ + key: 'node.data-availability.parent-chain-node-url'; + type: string; + } + | { + /** Data Availability Service timeout duration for Store requests (default 5s) */ + key: 'node.data-availability.request-timeout'; + type: string; + } + | { + /** enable retrieval of sequencer batch data from a list of remote REST endpoints; if other DAS storage types are enabled, this mode is used as a fallback */ + key: 'node.data-availability.rest-aggregator.enable'; + type: boolean; + } + | { + /** number of stats entries (latency and success rate) to keep for each REST endpoint; controls whether strategy is faster or slower to respond to changing conditions (default 20) */ + key: 'node.data-availability.rest-aggregator.max-per-endpoint-stats'; + type: number; + } + | { + /** a URL to a list of URLs of REST das endpoints that is checked at startup; additive with the url option */ + key: 'node.data-availability.rest-aggregator.online-url-list'; + type: string; + } + | { + /** time interval to periodically fetch url list from online-url-list (default 1h0m0s) */ + key: 'node.data-availability.rest-aggregator.online-url-list-fetch-interval'; + type: string; + } + | { + /** number of consecutive GetByHash calls to the aggregator where each call will cause it to select from REST endpoints in order of best latency and success rate, before switching to explore mode (default 1000) */ + key: 'node.data-availability.rest-aggregator.simple-explore-exploit-strategy.exploit-iterations'; + type: number; + } + | { + /** number of consecutive GetByHash calls to the aggregator where each call will cause it to randomly select from REST endpoints until one returns successfully, before switching to exploit mode (default 20) */ + key: 'node.data-availability.rest-aggregator.simple-explore-exploit-strategy.explore-iterations'; + type: number; + } + | { + /** strategy to use to determine order and parallelism of calling REST endpoint URLs; valid options are 'simple-explore-exploit' (default "simple-explore-exploit") */ + key: 'node.data-availability.rest-aggregator.strategy'; + type: string; + } + | { + /** how frequently to update the strategy with endpoint latency and error rate data (default 10s) */ + key: 'node.data-availability.rest-aggregator.strategy-update-interval'; + type: string; + } + | { + /** check if the data already exists in this DAS's storage. Must be disabled for fast sync with an IPFS backend (default true) */ + key: 'node.data-availability.rest-aggregator.sync-to-storage.check-already-exists'; + type: boolean; + } + | { + /** time to wait if encountered an error before retrying (default 1s) */ + key: 'node.data-availability.rest-aggregator.sync-to-storage.delay-on-error'; + type: string; + } + | { + /** eagerly sync batch data to this DAS's storage from the rest endpoints, using L1 as the index of batch data hashes; otherwise only sync lazily */ + key: 'node.data-availability.rest-aggregator.sync-to-storage.eager'; + type: boolean; + } + | { + /** when eagerly syncing, start indexing forward from this L1 block. Only used if there is no sync state */ + key: 'node.data-availability.rest-aggregator.sync-to-storage.eager-lower-bound-block'; + type: number; + } + | { + /** log only on failures to write when syncing; otherwise treat it as an error (default true) */ + key: 'node.data-availability.rest-aggregator.sync-to-storage.ignore-write-errors'; + type: boolean; + } + | { + /** when eagerly syncing, max l1 blocks to read per poll (default 100) */ + key: 'node.data-availability.rest-aggregator.sync-to-storage.parent-chain-blocks-per-read'; + type: number; + } + | { + /** period to retain synced data (defaults to forever) (default 2562047h47m16.854775807s) */ + key: 'node.data-availability.rest-aggregator.sync-to-storage.retention-period'; + type: string; + } + | { + /** directory to store the sync state in, ie the block number currently synced up to, so that we don't sync from scratch each time */ + key: 'node.data-availability.rest-aggregator.sync-to-storage.state-dir'; + type: string; + } + | { + /** list of URLs including 'http://' or 'https://' prefixes and port numbers to REST DAS endpoints; additive with the online-url-list option */ + key: 'node.data-availability.rest-aggregator.urls'; + type: string[]; + } + | { + /** time to wait until trying the next set of REST endpoints while waiting for a response; the next set of REST endpoints is determined by the strategy selected (default 2s) */ + key: 'node.data-availability.rest-aggregator.wait-before-try-next'; + type: string; + } + | { + /** Number of assumed honest backends (H). If there are N backends, K=N+1-H valid responses are required to consider an Store request to be successful. */ + key: 'node.data-availability.rpc-aggregator.assumed-honest'; + type: number; + } + | { + /** JSON RPC backend configuration */ + key: 'node.data-availability.rpc-aggregator.backends'; + type: string; + } + | { + /** enable storage/retrieval of sequencer batch data from a list of RPC endpoints; this should only be used by the batch poster and not in combination with other DAS storage types */ + key: 'node.data-availability.rpc-aggregator.enable'; + type: boolean; + } + | { + /** parent chain address of SequencerInbox contract */ + key: 'node.data-availability.sequencer-inbox-address'; + type: string; + } + | { + /** enable delayed sequencer */ + key: 'node.delayed-sequencer.enable'; + type: boolean; + } + | { + /** how many blocks in the past L1 block is considered final (ignored when using Merge finality) (default 20) */ + key: 'node.delayed-sequencer.finalize-distance'; + type: number; + } + | { + /** whether to wait for full finality before sequencing delayed messages */ + key: 'node.delayed-sequencer.require-full-finality'; + type: boolean; + } + | { + /** whether to use The Merge's notion of finality before sequencing delayed messages (default true) */ + key: 'node.delayed-sequencer.use-merge-finality'; + type: boolean; + } + | { + /** enable per message deflate compression support (default true) */ + key: 'node.feed.input.enable-compression'; + type: boolean; + } + | { + /** initial duration to wait before reconnect (default 1s) */ + key: 'node.feed.input.reconnect-initial-backoff'; + type: string; + } + | { + /** maximum duration to wait before reconnect (default 1m4s) */ + key: 'node.feed.input.reconnect-maximum-backoff'; + type: string; + } + | { + /** require chain id to be present on connect */ + key: 'node.feed.input.require-chain-id'; + type: boolean; + } + | { + /** require feed version to be present on connect */ + key: 'node.feed.input.require-feed-version'; + type: boolean; + } + | { + /** list of secondary URLs of sequencer feed source. Would be started in the order they appear in the list when primary feeds fails */ + key: 'node.feed.input.secondary-url'; + type: string[]; + } + | { + /** duration to wait before timing out connection to sequencer feed (default 20s) */ + key: 'node.feed.input.timeout'; + type: string; + } + | { + /** list of primary URLs of sequencer feed source */ + key: 'node.feed.input.url'; + type: string[]; + } + | { + /** accept verified message from sequencer (default true) */ + key: 'node.feed.input.verify.accept-sequencer'; + type: boolean; + } + | { + /** a list of allowed addresses */ + key: 'node.feed.input.verify.allowed-addresses'; + type: string[]; + } + | { + /** accept empty as valid signature (default true) */ + key: 'node.feed.input.verify.dangerous.accept-missing'; + type: boolean; + } + | { + /** address to bind the relay feed output to */ + key: 'node.feed.output.addr'; + type: string; + } + | { + /** the maximum number of messages each segment within the backlog can contain (default 240) */ + key: 'node.feed.output.backlog.segment-limit'; + type: number; + } + | { + /** delay the first messages sent to each client by this amount */ + key: 'node.feed.output.client-delay'; + type: string; + } + | { + /** duration to wait before timing out connections to client (default 15s) */ + key: 'node.feed.output.client-timeout'; + type: string; + } + | { + /** enable broadcaster per-client connection limiting */ + key: 'node.feed.output.connection-limits.enable'; + type: boolean; + } + | { + /** limit clients, as identified by IPv4/v6 address, to this many connections to this relay (default 5) */ + key: 'node.feed.output.connection-limits.per-ip-limit'; + type: number; + } + | { + /** limit ipv6 clients, as identified by IPv6 address masked with /48, to this many connections to this relay (default 20) */ + key: 'node.feed.output.connection-limits.per-ipv6-cidr-48-limit'; + type: number; + } + | { + /** limit ipv6 clients, as identified by IPv6 address masked with /64, to this many connections to this relay (default 10) */ + key: 'node.feed.output.connection-limits.per-ipv6-cidr-64-limit'; + type: number; + } + | { + /** time to wait after a relay client disconnects before the disconnect is registered with respect to the limit for this client */ + key: 'node.feed.output.connection-limits.reconnect-cooldown-period'; + type: string; + } + | { + /** don't sign feed messages (default true) */ + key: 'node.feed.output.disable-signing'; + type: boolean; + } + | { + /** enable broadcaster */ + key: 'node.feed.output.enable'; + type: boolean; + } + | { + /** enable per message deflate compression support */ + key: 'node.feed.output.enable-compression'; + type: boolean; + } + | { + /** duration to wait before timing out HTTP to WS upgrade (default 1s) */ + key: 'node.feed.output.handshake-timeout'; + type: string; + } + | { + /** only supply catchup buffer if requested sequence number is reasonable */ + key: 'node.feed.output.limit-catchup'; + type: boolean; + } + | { + /** log every client connect */ + key: 'node.feed.output.log-connect'; + type: boolean; + } + | { + /** log every client disconnect */ + key: 'node.feed.output.log-disconnect'; + type: boolean; + } + | { + /** the maximum size of the catchup buffer (-1 means unlimited) (default -1) */ + key: 'node.feed.output.max-catchup'; + type: number; + } + | { + /** maximum number of messages allowed to accumulate before client is disconnected (default 4096) */ + key: 'node.feed.output.max-send-queue'; + type: number; + } + | { + /** duration for ping interval (default 5s) */ + key: 'node.feed.output.ping'; + type: string; + } + | { + /** port to bind the relay feed output to (default "9642") */ + key: 'node.feed.output.port'; + type: string; + } + | { + /** queue size for HTTP to WS upgrade (default 100) */ + key: 'node.feed.output.queue'; + type: number; + } + | { + /** duration to wait before timing out reading data (i.e. pings) from clients (default 1s) */ + key: 'node.feed.output.read-timeout'; + type: string; + } + | { + /** require clients to use compression */ + key: 'node.feed.output.require-compression'; + type: boolean; + } + | { + /** don't connect if client version not present */ + key: 'node.feed.output.require-version'; + type: boolean; + } + | { + /** sign broadcast messages */ + key: 'node.feed.output.signed'; + type: boolean; + } + | { + /** number of threads to reserve for HTTP to WS upgrade (default 100) */ + key: 'node.feed.output.workers'; + type: number; + } + | { + /** duration to wait before timing out writing data to clients (default 2s) */ + key: 'node.feed.output.write-timeout'; + type: string; + } + | { + /** the maximum time to wait between inbox checks (if not enough new blocks are found) (default 1m0s) */ + key: 'node.inbox-reader.check-delay'; + type: string; + } + | { + /** the default number of blocks to read at once (will vary based on traffic by default) (default 100) */ + key: 'node.inbox-reader.default-blocks-to-read'; + type: number; + } + | { + /** number of latest blocks to ignore to reduce reorgs */ + key: 'node.inbox-reader.delay-blocks'; + type: number; + } + | { + /** erase future transactions in addition to overwriting existing ones on reorg */ + key: 'node.inbox-reader.hard-reorg'; + type: boolean; + } + | { + /** if adjust-blocks-to-read is enabled, the maximum number of blocks to read at once (default 2000) */ + key: 'node.inbox-reader.max-blocks-to-read'; + type: number; + } + | { + /** the minimum number of blocks to read at once (when caught up lowers load on L1) (default 1) */ + key: 'node.inbox-reader.min-blocks-to-read'; + type: number; + } + | { + /** mode to only read latest or safe or finalized L1 blocks. Enabling safe or finalized disables feed input and output. Defaults to latest. Takes string input, valid strings- latest, safe, finalized (default "latest") */ + key: 'node.inbox-reader.read-mode'; + type: string; + } + | { + /** if adjust-blocks-to-read is enabled, the target number of messages to read at once (default 500) */ + key: 'node.inbox-reader.target-messages-read'; + type: number; + } + | { + /** should node always try grabing lock in background */ + key: 'node.maintenance.lock.background-lock'; + type: boolean; + } + | { + /** if false, always treat this as locked and don't write the lock to redis (default true) */ + key: 'node.maintenance.lock.enable'; + type: boolean; + } + | { + /** key for lock */ + key: 'node.maintenance.lock.key'; + type: string; + } + | { + /** how long lock is held (default 1m0s) */ + key: 'node.maintenance.lock.lockout-duration'; + type: string; + } + | { + /** this node's id prefix when acquiring the lock (optional) */ + key: 'node.maintenance.lock.my-id'; + type: string; + } + | { + /** how long between consecutive calls to redis (default 10s) */ + key: 'node.maintenance.lock.refresh-duration'; + type: string; + } + | { + /** UTC 24-hour time of day to run maintenance (currently only db compaction) at (e.g. 15:00) */ + key: 'node.maintenance.time-of-day'; + type: string; + } + | { + /** enable message pruning (default true) */ + key: 'node.message-pruner.enable'; + type: boolean; + } + | { + /** min number of batches not pruned (default 2) */ + key: 'node.message-pruner.min-batches-left'; + type: number; + } + | { + /** interval for running message pruner (default 1m0s) */ + key: 'node.message-pruner.prune-interval'; + type: string; + } + | { + /** Dangerous! only meant to be used by system tests */ + key: 'node.parent-chain-reader.dangerous.wait-for-tx-approval-safe-poll'; + type: string; + } + | { + /** enable reader connection (default true) */ + key: 'node.parent-chain-reader.enable'; + type: boolean; + } + | { + /** warns if the latest l1 block is at least this old (default 5m0s) */ + key: 'node.parent-chain-reader.old-header-timeout'; + type: string; + } + | { + /** interval when polling endpoint (default 15s) */ + key: 'node.parent-chain-reader.poll-interval'; + type: string; + } + | { + /** do not attempt to subscribe to header events */ + key: 'node.parent-chain-reader.poll-only'; + type: boolean; + } + | { + /** interval for subscribe error (default 5m0s) */ + key: 'node.parent-chain-reader.subscribe-err-interval'; + type: string; + } + | { + /** timeout when waiting for a transaction (default 5m0s) */ + key: 'node.parent-chain-reader.tx-timeout'; + type: string; + } + | { + /** use l1 data about finalized/safe blocks (default true) */ + key: 'node.parent-chain-reader.use-finality-data'; + type: boolean; + } + | { + /** if non-empty, launch an HTTP service binding to this address that returns status code 200 when chosen and 503 otherwise */ + key: 'node.seq-coordinator.chosen-healthcheck-addr'; + type: string; + } + | { + /** enable sequence coordinator */ + key: 'node.seq-coordinator.enable'; + type: boolean; + } + | { + /** the maximum amount of time to spend waiting for another sequencer to accept the lockout when handing it off on shutdown or db compaction (default 30s) */ + key: 'node.seq-coordinator.handoff-timeout'; + type: string; + } + | { + /** (default 1m0s) */ + key: 'node.seq-coordinator.lockout-duration'; + type: string; + } + | { + /** (default 30s) */ + key: 'node.seq-coordinator.lockout-spare'; + type: string; + } + | { + /** will only be marked as wanting the lockout if not too far behind (default 2000) */ + key: 'node.seq-coordinator.msg-per-poll'; + type: number; + } + | { + /** url for this sequencer if it is the chosen (default "") */ + key: 'node.seq-coordinator.my-url'; + type: string; + } + | { + /** the Redis URL to coordinate via */ + key: 'node.seq-coordinator.redis-url'; + type: string; + } + | { + /** the number of times to retry releasing the wants lockout and chosen one status on shutdown (default 4) */ + key: 'node.seq-coordinator.release-retries'; + type: number; + } + | { + /** (default 50ms) */ + key: 'node.seq-coordinator.retry-interval'; + type: string; + } + | { + /** if non-zero will add delay after transferring control (default 5s) */ + key: 'node.seq-coordinator.safe-shutdown-delay'; + type: string; + } + | { + /** (default 24h0m0s) */ + key: 'node.seq-coordinator.seq-num-duration'; + type: string; + } + | { + /** accept verified message from sequencer (default true) */ + key: 'node.seq-coordinator.signer.ecdsa.accept-sequencer'; + type: boolean; + } + | { + /** a list of allowed addresses */ + key: 'node.seq-coordinator.signer.ecdsa.allowed-addresses'; + type: string[]; + } + | { + /** accept empty as valid signature (default true) */ + key: 'node.seq-coordinator.signer.ecdsa.dangerous.accept-missing'; + type: boolean; + } + | { + /** if to fall back to symmetric hmac */ + key: 'node.seq-coordinator.signer.symmetric-fallback'; + type: boolean; + } + | { + /** if to sign with symmetric hmac */ + key: 'node.seq-coordinator.signer.symmetric-sign'; + type: boolean; + } + | { + /** disable message signature verification */ + key: 'node.seq-coordinator.signer.symmetric.dangerous.disable-signature-verification'; + type: boolean; + } + | { + /** a fallback key used for message verification */ + key: 'node.seq-coordinator.signer.symmetric.fallback-verification-key'; + type: string; + } + | { + /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ + key: 'node.seq-coordinator.signer.symmetric.signing-key'; + type: string; + } + | { + /** (default 250ms) */ + key: 'node.seq-coordinator.update-interval'; + type: string; + } + | { + /** enable sequencer */ + key: 'node.sequencer'; + type: boolean; + } + | { + /** confirmation blocks (default 12) */ + key: 'node.staker.confirmation-blocks'; + type: number; + } + | { + /** validator smart contract wallet public address */ + key: 'node.staker.contract-wallet-address'; + type: string; + } + | { + /** DANGEROUS! make assertions even when the wasm module root is wrong */ + key: 'node.staker.dangerous.ignore-rollup-wasm-module-root'; + type: boolean; + } + | { + /** DANGEROUS! allows running an L1 validator without a block validator */ + key: 'node.staker.dangerous.without-block-validator'; + type: boolean; + } + | { + /** if true, don't put transactions in the mempool that spend a total greater than the batch poster's balance (default true) */ + key: 'node.staker.data-poster.allocate-mempool-balance'; + type: boolean; + } + | { + /** comma-separated list of durations since first posting a blob transaction to attempt a replace-by-fee (default "5m,10m,30m,1h,4h,8h,16h,22h") */ + key: 'node.staker.data-poster.blob-tx-replacement-times'; + type: string; + } + | { + /** clear database storage */ + key: 'node.staker.data-poster.dangerous.clear-dbstorage'; + type: boolean; + } + | { + /** unit to measure the time elapsed since creation of transaction used for maximum fee cap calculation (default 10m0s) */ + key: 'node.staker.data-poster.elapsed-time-base'; + type: string; + } + | { + /** weight given to the units of time elapsed used for maximum fee cap calculation (default 10) */ + key: 'node.staker.data-poster.elapsed-time-importance'; + type: number; + } + | { + /** external signer address */ + key: 'node.staker.data-poster.external-signer.address'; + type: string; + } + | { + /** rpc client cert */ + key: 'node.staker.data-poster.external-signer.client-cert'; + type: string; + } + | { + /** rpc client private key */ + key: 'node.staker.data-poster.external-signer.client-private-key'; + type: string; + } + | { + /** external signer method (default "eth_signTransaction") */ + key: 'node.staker.data-poster.external-signer.method'; + type: string; + } + | { + /** external signer root CA */ + key: 'node.staker.data-poster.external-signer.root-ca'; + type: string; + } + | { + /** external signer url */ + key: 'node.staker.data-poster.external-signer.url'; + type: string; + } + | { + /** encodes items in a legacy way (as it was before dropping generics) */ + key: 'node.staker.data-poster.legacy-storage-encoding'; + type: boolean; + } + | { + /** the maximum tip cap to post EIP-4844 blob carrying transactions at (default 1) */ + key: 'node.staker.data-poster.max-blob-tx-tip-cap-gwei'; + type: number; + } + | { + /** the maximum multiple of the current price to bid for a transaction's fees (may be exceeded due to min rbf increase, 0 = unlimited) (default 100000) */ + key: 'node.staker.data-poster.max-fee-bid-multiple-bips'; + type: number; + } + | { + /** mathematical formula to calculate maximum fee cap gwei the result of which would be float64. This expression is expected to be evaluated please refer https://github.com/Knetic/govaluate/blob/master/MANUAL.md to find all available mathematical operators. Currently available variables to construct the formula are BacklogOfBatches, UrgencyGWei, ElapsedTime, ElapsedTimeBase, ElapsedTimeImportance, and TargetPriceGWei (default "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei") */ + key: 'node.staker.data-poster.max-fee-cap-formula'; + type: string; + } + | { + /** the maximum number of transactions to have queued in the mempool at once (0 = unlimited) (default 1) */ + key: 'node.staker.data-poster.max-mempool-transactions'; + type: number; + } + | { + /** the maximum number of weight (weight = min(1, tx.blobs)) to have queued in the mempool at once (0 = unlimited) (default 1) */ + key: 'node.staker.data-poster.max-mempool-weight'; + type: number; + } + | { + /** the maximum number of unconfirmed transactions to track at once (0 = unlimited) */ + key: 'node.staker.data-poster.max-queued-transactions'; + type: number; + } + | { + /** the maximum tip cap to post transactions at (default 5) */ + key: 'node.staker.data-poster.max-tip-cap-gwei'; + type: number; + } + | { + /** the minimum tip cap to post EIP-4844 blob carrying transactions at (default 1) */ + key: 'node.staker.data-poster.min-blob-tx-tip-cap-gwei'; + type: number; + } + | { + /** the minimum tip cap to post transactions at (default 0.05) */ + key: 'node.staker.data-poster.min-tip-cap-gwei'; + type: number; + } + | { + /** the maximum probable reorg depth, used to determine when a transaction will no longer likely need replaced-by-fee (default 1) */ + key: 'node.staker.data-poster.nonce-rbf-soft-confs'; + type: number; + } + | { + /** disable message signature verification */ + key: 'node.staker.data-poster.redis-signer.dangerous.disable-signature-verification'; + type: boolean; + } + | { + /** a fallback key used for message verification */ + key: 'node.staker.data-poster.redis-signer.fallback-verification-key'; + type: string; + } + | { + /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ + key: 'node.staker.data-poster.redis-signer.signing-key'; + type: string; + } + | { + /** comma-separated list of durations since first posting to attempt a replace-by-fee (default "5m,10m,20m,30m,1h,2h,4h,6h,8h,12h,16h,18h,20h,22h") */ + key: 'node.staker.data-poster.replacement-times'; + type: string; + } + | { + /** the target price to use for maximum fee cap calculation (default 60) */ + key: 'node.staker.data-poster.target-price-gwei'; + type: number; + } + | { + /** the urgency to use for maximum fee cap calculation (default 2) */ + key: 'node.staker.data-poster.urgency-gwei'; + type: number; + } + | { + /** uses database storage when enabled (default true) */ + key: 'node.staker.data-poster.use-db-storage'; + type: boolean; + } + | { + /** uses noop storage, it doesn't store anything */ + key: 'node.staker.data-poster.use-noop-storage'; + type: boolean; + } + | { + /** only treat a transaction as confirmed after L1 finality has been achieved (recommended) (default true) */ + key: 'node.staker.data-poster.wait-for-l1-finality'; + type: boolean; + } + | { + /** disable validator challenge */ + key: 'node.staker.disable-challenge'; + type: boolean; + } + | { + /** enable validator (default true) */ + key: 'node.staker.enable'; + type: boolean; + } + | { + /** use this much more gas than estimation says is necessary to post transactions (default 50000) */ + key: 'node.staker.extra-gas'; + type: number; + } + | { + /** The gas refunder contract address (optional) */ + key: 'node.staker.gas-refunder-address'; + type: string; + } + | { + /** if configured with the makeNodes strategy, how often to create new assertions (bypassed in case of a dispute) (default 1h0m0s) */ + key: 'node.staker.make-assertion-interval'; + type: string; + } + | { + /** only create smart wallet contract and exit */ + key: 'node.staker.only-create-wallet-contract'; + type: boolean; + } + | { + /** account to use (default is first account in keystore) */ + key: 'node.staker.parent-chain-wallet.account'; + type: string; + } + | { + /** if true, creates new key then exits */ + key: 'node.staker.parent-chain-wallet.only-create-key'; + type: boolean; + } + | { + /** wallet passphrase (default "PASSWORD_NOT_SET") */ + key: 'node.staker.parent-chain-wallet.password'; + type: string; + } + | { + /** pathname for wallet (default "validator-wallet") */ + key: 'node.staker.parent-chain-wallet.pathname'; + type: string; + } + | { + /** private key for wallet */ + key: 'node.staker.parent-chain-wallet.private-key'; + type: string; + } + | { + /** high gas delay blocks */ + key: 'node.staker.posting-strategy.high-gas-delay-blocks'; + type: number; + } + | { + /** high gas threshold */ + key: 'node.staker.posting-strategy.high-gas-threshold'; + type: number; + } + | { + /** redis url for L1 validator */ + key: 'node.staker.redis-url'; + type: string; + } + | { + /** how often the L1 validator should check the status of the L1 rollup and maybe take action with its stake (default 1m0s) */ + key: 'node.staker.staker-interval'; + type: string; + } + | { + /** assume staked nodes are valid (default true) */ + key: 'node.staker.start-validation-from-staked'; + type: boolean; + } + | { + /** L1 validator strategy, either watchtower, defensive, stakeLatest, or makeNodes (default "Watchtower") */ + key: 'node.staker.strategy'; + type: string; + } + | { + /** use a smart contract wallet instead of an EOA address */ + key: 'node.staker.use-smart-contract-wallet'; + type: boolean; + } + | { + /** allowed lag between messages read and blocks built (default 20) */ + key: 'node.sync-monitor.block-build-lag'; + type: number; + } + | { + /** allowed lag between messages read from sequencer inbox and blocks built */ + key: 'node.sync-monitor.block-build-sequencer-inbox-lag'; + type: number; + } + | { + /** allowed lag between local and remote messages (default 15) */ + key: 'node.sync-monitor.coordinator-msg-lag'; + type: number; + } + | { + /** wait for block validator to complete before returning finalized block number */ + key: 'node.sync-monitor.finalized-block-wait-for-block-validator'; + type: boolean; + } + | { + /** wait for block validator to complete before returning safe block number */ + key: 'node.sync-monitor.safe-block-wait-for-block-validator'; + type: boolean; + } + | { + /** delay when polling calls to execute messages (default 100ms) */ + key: 'node.transaction-streamer.execute-message-loop-delay'; + type: string; + } + | { + /** maximum cache of pending broadcaster messages (default 50000) */ + key: 'node.transaction-streamer.max-broadcaster-queue-size'; + type: number; + } + | { + /** maximum number of messages to attempt to resequence on reorg (0 = never resequence, -1 = always resequence) (default 1024) */ + key: 'node.transaction-streamer.max-reorg-resequence-depth'; + type: number; + } + | { + /** P2P bootnodes */ + key: 'p2p.bootnodes'; + type: string[]; + } + | { + /** P2P bootnodes v5 */ + key: 'p2p.bootnodes-v5'; + type: string[]; + } + | { + /** P2P discovery v4 */ + key: 'p2p.discovery-v4'; + type: boolean; + } + | { + /** P2P discovery v5 */ + key: 'p2p.discovery-v5'; + type: boolean; + } + | { + /** P2P listen address */ + key: 'p2p.listen-addr'; + type: string; + } + | { + /** P2P max peers (default 50) */ + key: 'p2p.max-peers'; + type: number; + } + | { + /** P2P no dial (default true) */ + key: 'p2p.no-dial'; + type: boolean; + } + | { + /** P2P no discovery (default true) */ + key: 'p2p.no-discovery'; + type: boolean; + } + | { + /** Value to send with the HTTP Authorization: header for Beacon REST requests, must include both scheme and scheme parameters */ + key: 'parent-chain.blob-client.authorization'; + type: string; + } + | { + /** Beacon Chain RPC URL to use for fetching blobs (normally on port 3500) */ + key: 'parent-chain.blob-client.beacon-url'; + type: string; + } + | { + /** Full path of the directory to save fetched blobs */ + key: 'parent-chain.blob-client.blob-directory'; + type: string; + } + | { + /** Backup beacon Chain RPC URL to use for fetching blobs (normally on port 3500) when unable to fetch from primary */ + key: 'parent-chain.blob-client.secondary-beacon-url'; + type: string; + } + | { + /** limit size of arguments in log entries (default 2048) */ + key: 'parent-chain.connection.arg-log-limit'; + type: number; + } + | { + /** how long to wait for initial connection (default 1m0s) */ + key: 'parent-chain.connection.connection-wait'; + type: string; + } + | { + /** path to file with jwtsecret for validation - ignored if url is self or self-auth */ + key: 'parent-chain.connection.jwtsecret'; + type: string; + } + | { + /** number of retries in case of failure(0 mean one attempt) (default 2) */ + key: 'parent-chain.connection.retries'; + type: number; + } + | { + /** delay between retries */ + key: 'parent-chain.connection.retry-delay'; + type: string; + } + | { + /** Errors matching this regular expression are automatically retried */ + key: 'parent-chain.connection.retry-errors'; + type: string; + } + | { + /** per-response timeout (0-disabled) (default 1m0s) */ + key: 'parent-chain.connection.timeout'; + type: string; + } + | { + /** url of server, use self for loopback websocket, self-auth for loopback with authentication */ + key: 'parent-chain.connection.url'; + type: string; + } + | { + /** if set other than 0, will be used to validate database and L1 connection */ + key: 'parent-chain.id'; + type: number; + } + | { + /** account to use (default is first account in keystore) */ + key: 'parent-chain.wallet.account'; + type: string; + } + | { + /** if true, creates new key then exits */ + key: 'parent-chain.wallet.only-create-key'; + type: boolean; + } + | { + /** wallet passphrase (default "PASSWORD_NOT_SET") */ + key: 'parent-chain.wallet.password'; + type: string; + } + | { + /** pathname for wallet (default "wallet") */ + key: 'parent-chain.wallet.pathname'; + type: string; + } + | { + /** private key for wallet */ + key: 'parent-chain.wallet.private-key'; + type: string; + } + | { + /** directory of ancient where the chain freezer can be opened */ + key: 'persistent.ancient'; + type: string; + } + | { + /** directory to store chain state */ + key: 'persistent.chain'; + type: string; + } + | { + /** backing database implementation to use ('leveldb' or 'pebble') (default "leveldb") */ + key: 'persistent.db-engine'; + type: string; + } + | { + /** directory to store global config (default ".arbitrum") */ + key: 'persistent.global-config'; + type: string; + } + | { + /** number of file descriptor handles to use for the database (default 512) */ + key: 'persistent.handles'; + type: number; + } + | { + /** directory to store log file */ + key: 'persistent.log-dir'; + type: string; + } + | { + /** enable pprof */ + key: 'pprof'; + type: boolean; + } + | { + /** pprof server address (default "127.0.0.1") */ + key: 'pprof-cfg.addr'; + type: string; + } + | { + /** pprof server port (default 6071) */ + key: 'pprof-cfg.port'; + type: number; + } + | { + /** the maximum number of requests in a batch (0 means no limit) (default 1000) */ + key: 'rpc.batch-request-limit'; + type: number; + } + | { + /** the maximum response size for a JSON-RPC request measured in bytes (0 means no limit) (default 10000000) */ + key: 'rpc.max-batch-response-size'; + type: number; + } + | { + /** validate is an authenticated API (default true) */ + key: 'validation.api-auth'; + type: boolean; + } + | { + /** validate is a public API */ + key: 'validation.api-public'; + type: boolean; + } + | { + /** timeout before discarding execution run (default 15m0s) */ + key: 'validation.arbitrator.execution-run-timeout'; + type: string; + } + | { + /** how many machines to store in cache while working on a challenge (should be even) (default 4) */ + key: 'validation.arbitrator.execution.cached-challenge-machines'; + type: number; + } + | { + /** initial steps between machines (default 100000) */ + key: 'validation.arbitrator.execution.initial-steps'; + type: number; + } + | { + /** path to write machines to (default "./target/output") */ + key: 'validation.arbitrator.output-path'; + type: string; + } + | { + /** number of concurrent validation threads */ + key: 'validation.arbitrator.workers'; + type: number; + } + | { + /** use Cranelift instead of LLVM when validating blocks using the jit-accelerated block validator (default true) */ + key: 'validation.jit.cranelift'; + type: boolean; + } + | { + /** if memory used by a jit wasm exceeds this limit, a warning is logged (default 4294967296) */ + key: 'validation.jit.wasm-memory-usage-limit'; + type: number; + } + | { + /** number of concurrent validation threads */ + key: 'validation.jit.workers'; + type: number; + } + | { + /** use jit for validation (default true) */ + key: 'validation.use-jit'; + type: boolean; + } + | { + /** list of WASM module roots to check if the on-chain WASM module root belongs to on node startup */ + key: 'validation.wasm.allowed-wasm-module-roots'; + type: string[]; + } + | { + /** enable check for compatibility of on-chain WASM module root with node (default true) */ + key: 'validation.wasm.enable-wasmroots-check'; + type: boolean; + } + | { + /** path to machine folders, each containing wasm files (machine.wavm.br, replay.wasm) */ + key: 'validation.wasm.root-path'; + type: string; + } + | { + /** WS-RPC server listening interface */ + key: 'ws.addr'; + type: string; + } + | { + /** APIs offered over the WS-RPC interface (default [net,web3,eth,arb]) */ + key: 'ws.api'; + type: string[]; + } + | { + /** expose private api via websocket */ + key: 'ws.expose-all'; + type: boolean; + } + | { + /** Origins from which to accept websockets requests */ + key: 'ws.origins'; + type: string[]; + } + | { + /** WS-RPC server listening port (default 8548) */ + key: 'ws.port'; + type: number; + } + | { + /** WS path path prefix on which JSON-RPC is served. Use '/' to serve on all paths */ + key: 'ws.rpcprefix'; + type: string; + }; diff --git a/src/types/NodeConfig.generated/index.ts b/src/types/NodeConfig.generated/index.ts deleted file mode 100644 index 23112d85..00000000 --- a/src/types/NodeConfig.generated/index.ts +++ /dev/null @@ -1,2 +0,0 @@ -// this file should always export the latest version -export * from './versions/v2.3.0-3e14543'; diff --git a/src/types/NodeConfig.generated/versions/v2.3.0-3e14543.ts b/src/types/NodeConfig.generated/versions/v2.3.0-3e14543.ts deleted file mode 100644 index b48c3dd1..00000000 --- a/src/types/NodeConfig.generated/versions/v2.3.0-3e14543.ts +++ /dev/null @@ -1,3376 +0,0 @@ -// --- -// -// THIS FILE IS AUTOMATICALLY GENERATED AND SHOULD NOT BE EDITED MANUALLY -// -// IMAGE: offchainlabs/nitro-node:v2.3.0-3e14543 -// TIMESTAMP: 2024-02-29T15:44:11.800Z -// -// --- -/** Nitro node configuration object */ -export type NodeConfig = { - 'auth'?: { - /** AUTH-RPC server listening interface (default "127.0.0.1") */ - addr?: string; - /** APIs offered over the AUTH-RPC interface (default [validation]) */ - api?: string[]; - /** Path to file holding JWT secret (32B hex) */ - jwtsecret?: string; - /** Origins from which to accept AUTH requests (default [localhost]) */ - origins?: string[]; - /** AUTH-RPC server listening port (default 8549) */ - port?: number; - }; - 'blocks-reexecutor'?: { - /** minimum number of blocks to execute per thread. When mode is random this acts as the size of random block range sample (default 10000) */ - 'blocks-per-thread'?: number; - /** enables re-execution of a range of blocks against historic state */ - 'enable'?: boolean; - /** last block number of the block range for re-execution */ - 'end-block'?: number; - /** mode to run the blocks-reexecutor on. Valid modes full and random. full - execute all the blocks in the given range. random - execute a random sample range of blocks with in a given range (default "random") */ - 'mode'?: string; - /** number of threads to parallelize blocks re-execution (default 12) */ - 'room'?: number; - /** first block number of the block range for re-execution */ - 'start-block'?: number; - }; - 'chain'?: { - 'dev-wallet'?: { - /** account to use (default is first account in keystore) */ - 'account'?: string; - /** if true, creates new key then exits */ - 'only-create-key'?: boolean; - /** wallet passphrase (default "PASSWORD_NOT_SET") */ - 'password'?: string; - /** pathname for wallet */ - 'pathname'?: string; - /** private key for wallet */ - 'private-key'?: string; - }; - /** L2 chain ID (determines Arbitrum network) */ - 'id'?: number; - /** L2 chain info json files */ - 'info-files'?: string[]; - /** path to save temp downloaded file (default "/tmp/") */ - 'info-ipfs-download-path'?: string; - /** url to download chain info file */ - 'info-ipfs-url'?: string; - /** L2 chain info in json string format */ - 'info-json'?: string; - /** L2 chain name (determines Arbitrum network) */ - 'name'?: string; - }; - 'conf'?: { - /** print out currently active configuration file */ - 'dump'?: boolean; - /** environment variables with given prefix will be loaded as configuration values */ - 'env-prefix'?: string; - /** name of configuration file */ - 'file'?: string[]; - /** how often to reload configuration (0=disable periodic reloading) */ - 'reload-interval'?: string; - 's3'?: { - /** S3 access key */ - 'access-key'?: string; - /** S3 bucket */ - 'bucket'?: string; - /** S3 object key */ - 'object-key'?: string; - /** S3 region */ - 'region'?: string; - /** S3 secret key */ - 'secret-key'?: string; - }; - /** configuration as JSON string */ - 'string'?: string; - }; - 'execution'?: { - 'caching'?: { - /** retain past block state */ - 'archive'?: boolean; - /** minimum age of recent blocks to keep in memory (default 30m0s) */ - 'block-age'?: string; - /** minimum number of recent blocks to keep in memory (default 128) */ - 'block-count'?: number; - /** amount of memory in megabytes to cache database contents with (default 2048) */ - 'database-cache'?: number; - /** maximum amount of gas in blocks to skip saving state to Persistent storage (archive node only) -- warning: this option seems to cause issues */ - 'max-amount-of-gas-to-skip-state-saving'?: number; - /** maximum number of blocks to skip state saving to persistent storage (archive node only) -- warning: this option seems to cause issues */ - 'max-number-of-blocks-to-skip-state-saving'?: number; - /** amount of memory in megabytes to cache state snapshots with (default 400) */ - 'snapshot-cache'?: number; - /** maximum gas rolled back to recover snapshot (default 300000000000) */ - 'snapshot-restore-gas-limit'?: number; - /** amount of memory in megabytes to cache unchanged state trie nodes with (default 600) */ - 'trie-clean-cache'?: number; - /** amount of memory in megabytes to cache state diffs against disk with (larger cache lowers database growth) (default 1024) */ - 'trie-dirty-cache'?: number; - /** maximum block processing time before trie is written to hard-disk (default 1h0m0s) */ - 'trie-time-limit'?: string; - }; - 'dangerous'?: { - /** DANGEROUS! forces a reorg to an old block height. To be used for testing only. -1 to disable (default -1) */ - 'reorg-to-block'?: number; - }; - /** enable prefetching of blocks (default true) */ - 'enable-prefetch-block'?: boolean; - 'forwarder'?: { - /** total time to wait before cancelling connection (default 30s) */ - 'connection-timeout'?: string; - /** time until idle connections are closed (default 15s) */ - 'idle-connection-timeout'?: string; - /** maximum number of idle connections to keep open (default 1) */ - 'max-idle-connections'?: number; - /** the Redis URL to recomend target via */ - 'redis-url'?: string; - /** minimal time between update retries (default 100ms) */ - 'retry-interval'?: string; - /** forwarding target update interval (default 1s) */ - 'update-interval'?: string; - }; - /** transaction forwarding target URL, or "null" to disable forwarding (iff not sequencer) */ - 'forwarding-target'?: string; - 'parent-chain-reader'?: { - 'dangerous'?: { - /** Dangerous! only meant to be used by system tests */ - 'wait-for-tx-approval-safe-poll'?: string; - }; - /** enable reader connection (default true) */ - 'enable'?: boolean; - /** warns if the latest l1 block is at least this old (default 5m0s) */ - 'old-header-timeout'?: string; - /** interval when polling endpoint (default 15s) */ - 'poll-interval'?: string; - /** do not attempt to subscribe to header events */ - 'poll-only'?: boolean; - /** interval for subscribe error (default 5m0s) */ - 'subscribe-err-interval'?: string; - /** timeout when waiting for a transaction (default 5m0s) */ - 'tx-timeout'?: string; - /** use l1 data about finalized/safe blocks (default true) */ - 'use-finality-data'?: boolean; - }; - 'recording-database'?: { - /** like trie-clean-cache for the separate, recording database (used for validation) (default 16) */ - 'trie-clean-cache'?: number; - /** like trie-dirty-cache for the separate, recording database (used for validation) (default 1024) */ - 'trie-dirty-cache'?: number; - }; - 'rpc'?: { - /** list of whitelisted rpc methods */ - 'allow-method'?: string[]; - 'arbdebug'?: { - /** bounds the number of blocks arbdebug calls may return (default 256) */ - 'block-range-bound'?: number; - /** bounds the length of timeout queues arbdebug calls may return (default 512) */ - 'timeout-queue-bound'?: number; - }; - /** number of blocks a single bloom bit section vector holds (default 16384) */ - 'bloom-bits-blocks'?: number; - /** number of confirmation blocks before a bloom section is considered final (default 256) */ - 'bloom-confirms'?: number; - /** url to redirect classic requests, use "error:[CODE:]MESSAGE" to return specified error instead of redirecting */ - 'classic-redirect'?: string; - /** timeout for forwarded classic requests, where 0 = no timeout */ - 'classic-redirect-timeout'?: string; - /** timeout used for eth_call (0=infinite) (default 5s) */ - 'evm-timeout'?: string; - /** max number of blocks a fee history request may cover (default 1024) */ - 'feehistory-max-block-count'?: number; - /** log filter system maximum number of cached blocks (default 32) */ - 'filter-log-cache-size'?: number; - /** log filter system maximum time filters stay active (default 5m0s) */ - 'filter-timeout'?: string; - /** cap on computation gas that can be used in eth_call/estimateGas (0=infinite) (default 50000000) */ - 'gas-cap'?: number; - /** maximum depth for recreating state, measured in l2 gas (0=don't recreate state, -1=infinite, -2=use default value for archive or non-archive node (whichever is configured)) (default -2) */ - 'max-recreate-state-depth'?: number; - /** allow transactions that aren't EIP-155 replay protected to be submitted over the RPC (default true) */ - 'tx-allow-unprotected'?: boolean; - /** cap on transaction fee (in ether) that can be sent via the RPC APIs (0 = no cap) (default 1) */ - 'tx-fee-cap'?: number; - }; - /** secondary transaction forwarding target URL */ - 'secondary-forwarding-target'?: string[]; - 'sequencer'?: { - /** act and post to l1 as sequencer */ - 'enable'?: boolean; - 'forwarder'?: { - /** total time to wait before cancelling connection (default 30s) */ - 'connection-timeout'?: string; - /** time until idle connections are closed (default 1m0s) */ - 'idle-connection-timeout'?: string; - /** maximum number of idle connections to keep open (default 100) */ - 'max-idle-connections'?: number; - /** the Redis URL to recomend target via */ - 'redis-url'?: string; - /** minimal time between update retries (default 100ms) */ - 'retry-interval'?: string; - /** forwarding target update interval (default 1s) */ - 'update-interval'?: string; - }; - /** maximum acceptable time difference between the local time and the latest L1 block's timestamp (default 1h0m0s) */ - 'max-acceptable-timestamp-delta'?: string; - /** minimum delay between blocks (sets a maximum speed of block production) (default 250ms) */ - 'max-block-speed'?: string; - /** maximum gas executed in a revert for the sequencer to reject the transaction instead of posting it (anti-DOS) (default 31000) */ - 'max-revert-gas-reject'?: number; - /** maximum transaction size the sequencer will accept (default 95000) */ - 'max-tx-data-size'?: number; - /** size of the tx sender nonce cache (default 1024) */ - 'nonce-cache-size'?: number; - /** maximum amount of time to wait for a predecessor before rejecting a tx with nonce too high (default 1s) */ - 'nonce-failure-cache-expiry'?: string; - /** number of transactions with too high of a nonce to keep in memory while waiting for their predecessor (default 1024) */ - 'nonce-failure-cache-size'?: number; - /** size of the pending tx queue (default 1024) */ - 'queue-size'?: number; - /** maximum amount of time transaction can wait in queue (default 12s) */ - 'queue-timeout'?: string; - /** comma separated whitelist of authorized senders (if empty, everyone is allowed) */ - 'sender-whitelist'?: string; - }; - /** retain the ability to lookup transactions by hash for the past N blocks (0 = all blocks) (default 126230400) */ - 'tx-lookup-limit'?: number; - 'tx-pre-checker'?: { - /** how long ago should the storage conditions from eth_SendRawTransactionConditional be true, 0 = don't check old state (default 2) */ - 'required-state-age'?: number; - /** maximum number of blocks to look back while looking for the seconds old state, 0 = don't limit the search (default 4) */ - 'required-state-max-blocks'?: number; - /** how strict to be when checking txs before forwarding them. 0 = accept anything, 10 = should never reject anything that'd succeed, 20 = likely won't reject anything that'd succeed, 30 = full validation which may reject txs that would succeed */ - 'strictness'?: number; - }; - }; - 'file-logging'?: { - /** size of intermediate log records buffer (default 512) */ - 'buf-size'?: number; - /** enable compression of old log files (default true) */ - 'compress'?: boolean; - /** enable logging to file (default true) */ - 'enable'?: boolean; - /** path to log file (default "nitro.log") */ - 'file'?: string; - /** if true: local time will be used in old log filename timestamps */ - 'local-time'?: boolean; - /** maximum number of days to retain old log files based on the timestamp encoded in their filename (0 = no limit) */ - 'max-age'?: number; - /** maximum number of old log files to retain (0 = no limit) (default 20) */ - 'max-backups'?: number; - /** log file size in Mb that will trigger log file rotation (0 = trigger disabled) (default 5) */ - 'max-size'?: number; - }; - 'graphql'?: { - /** Comma separated list of domains from which to accept cross origin requests (browser enforced) */ - corsdomain?: string[]; - /** Enable graphql endpoint on the rpc endpoint */ - enable?: boolean; - /** Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard (default [localhost]) */ - vhosts?: string[]; - }; - 'http'?: { - /** HTTP-RPC server listening interface */ - 'addr'?: string; - /** APIs offered over the HTTP-RPC interface (default [net,web3,eth,arb]) */ - 'api'?: string[]; - /** Comma separated list of domains from which to accept cross origin requests (browser enforced) */ - 'corsdomain'?: string[]; - /** HTTP-RPC server listening port (default 8547) */ - 'port'?: number; - /** HTTP path path prefix on which JSON-RPC is served. Use '/' to serve on all paths */ - 'rpcprefix'?: string; - 'server-timeouts'?: { - /** the maximum amount of time to wait for the next request when keep-alives are enabled (http.Server.IdleTimeout) (default 2m0s) */ - 'idle-timeout'?: string; - /** the amount of time allowed to read the request headers (http.Server.ReadHeaderTimeout) (default 30s) */ - 'read-header-timeout'?: string; - /** the maximum duration for reading the entire request (http.Server.ReadTimeout) (default 30s) */ - 'read-timeout'?: string; - /** the maximum duration before timing out writes of the response (http.Server.WriteTimeout) (default 30s) */ - 'write-timeout'?: string; - }; - /** Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard (default [localhost]) */ - 'vhosts'?: string[]; - }; - 'init'?: { - /** during init - sync database every X accounts. Lower value for low-memory systems. 0 disables. (default 100000) */ - 'accounts-per-sync'?: number; - /** init with dev data (1 account with balance) instead of file import */ - 'dev-init'?: boolean; - /** Address of dev-account. Leave empty to use the dev-wallet. */ - 'dev-init-address'?: string; - /** Number of preinit blocks. Must exist in ancient database. */ - 'dev-init-blocknum'?: number; - /** path to save temp downloaded file (default "/tmp/") */ - 'download-path'?: string; - /** how long to wait between polling attempts (default 1m0s) */ - 'download-poll'?: string; - /** init with empty state */ - 'empty'?: boolean; - /** if true: in case database exists init code will be reexecuted and genesis block compared to database */ - 'force'?: boolean; - /** path for json data to import */ - 'import-file'?: string; - /** pruning for a given use: "full" for full nodes serving RPC requests, or "validator" for validators */ - 'prune'?: string; - /** the amount of memory in megabytes to use for the pruning bloom filter (higher values prune better) (default 2048) */ - 'prune-bloom-size'?: number; - /** block number to start recreating missing states from (0 = disabled) */ - 'recreate-missing-state-from'?: number; - /** forces a reset to an old message height. Also set max-reorg-resequence-depth=0 to force re-reading messages (default -1) */ - 'reset-to-message'?: number; - /** quit after init is done */ - 'then-quit'?: boolean; - /** url to download initializtion data - will poll if download fails */ - 'url'?: string; - }; - 'ipc'?: { - /** Requested location to place the IPC endpoint. An empty path disables IPC. */ - path?: string; - }; - /** log level (default 3) */ - 'log-level'?: number; - /** log type (plaintext or json) (default "plaintext") */ - 'log-type'?: string; - /** enable metrics */ - 'metrics'?: boolean; - 'metrics-server'?: { - /** metrics server address (default "127.0.0.1") */ - 'addr'?: string; - /** metrics server port (default 6070) */ - 'port'?: number; - /** metrics server update interval (default 3s) */ - 'update-interval'?: string; - }; - 'node'?: { - 'batch-poster'?: { - /** batch compression level (default 11) */ - 'compression-level'?: number; - /** In AnyTrust mode, the period which DASes are requested to retain the stored batches. (default 360h0m0s) */ - 'das-retention-period'?: string; - 'data-poster'?: { - /** if true, don't put transactions in the mempool that spend a total greater than the batch poster's balance (default true) */ - 'allocate-mempool-balance'?: boolean; - 'dangerous'?: { - /** clear database storage */ - 'clear-dbstorage'?: boolean; - }; - /** unit to measure the time elapsed since creation of transaction used for maximum fee cap calculation (default 10m0s) */ - 'elapsed-time-base'?: string; - /** weight given to the units of time elapsed used for maximum fee cap calculation (default 10) */ - 'elapsed-time-importance'?: number; - 'external-signer'?: { - /** external signer address */ - 'address'?: string; - /** rpc client cert */ - 'client-cert'?: string; - /** rpc client private key */ - 'client-private-key'?: string; - /** external signer method (default "eth_signTransaction") */ - 'method'?: string; - /** external signer root CA */ - 'root-ca'?: string; - /** external signer url */ - 'url'?: string; - }; - /** encodes items in a legacy way (as it was before dropping generics) */ - 'legacy-storage-encoding'?: boolean; - /** mathematical formula to calculate maximum fee cap gwei the result of which would be float64. This expression is expected to be evaluated please refer https://github.com/Knetic/govaluate/blob/master/MANUAL.md to find all available mathematical operators. Currently available variables to construct the formula are BacklogOfBatches, UrgencyGWei, ElapsedTime, ElapsedTimeBase, ElapsedTimeImportance, and TargetPriceGWei (default "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei") */ - 'max-fee-cap-formula'?: string; - /** the maximum number of transactions to have queued in the mempool at once (0 = unlimited) (default 20) */ - 'max-mempool-transactions'?: number; - /** the maximum number of unconfirmed transactions to track at once (0 = unlimited) */ - 'max-queued-transactions'?: number; - /** the maximum tip cap to post transactions at (default 5) */ - 'max-tip-cap-gwei'?: number; - /** the minimum fee cap to post transactions at */ - 'min-fee-cap-gwei'?: number; - /** the minimum tip cap to post transactions at (default 0.05) */ - 'min-tip-cap-gwei'?: number; - /** the maximum probable reorg depth, used to determine when a transaction will no longer likely need replaced-by-fee (default 1) */ - 'nonce-rbf-soft-confs'?: number; - 'redis-signer'?: { - 'dangerous'?: { - /** disable message signature verification */ - 'disable-signature-verification'?: boolean; - }; - /** a fallback key used for message verification */ - 'fallback-verification-key'?: string; - /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ - 'signing-key'?: string; - }; - /** comma-separated list of durations since first posting to attempt a replace-by-fee (default "5m,10m,20m,30m,1h,2h,4h,6h,8h,12h,16h,18h,20h,22h") */ - 'replacement-times'?: string; - /** the target price to use for maximum fee cap calculation (default 60) */ - 'target-price-gwei'?: number; - /** the urgency to use for maximum fee cap calculation (default 2) */ - 'urgency-gwei'?: number; - /** uses database storage when enabled (default true) */ - 'use-db-storage'?: boolean; - /** uses noop storage, it doesn't store anything */ - 'use-noop-storage'?: boolean; - /** only treat a transaction as confirmed after L1 finality has been achieved (recommended) (default true) */ - 'wait-for-l1-finality'?: boolean; - }; - /** If unable to batch to DAS, disable fallback storing data on chain */ - 'disable-das-fallback-store-data-on-chain'?: boolean; - /** enable posting batches to l1 */ - 'enable'?: boolean; - /** how long to delay after error posting batch (default 10s) */ - 'error-delay'?: string; - /** use this much more gas than estimation says is necessary to post batches (default 50000) */ - 'extra-batch-gas'?: number; - /** The gas refunder contract address (optional) */ - 'gas-refunder-address'?: string; - /** if the parent chain supports 4844 blobs and ignore-blob-price is true, post 4844 blobs even if it's not price efficient */ - 'ignore-blob-price'?: boolean; - /** only post messages to batches when they're within the max future block/timestamp as of this L1 block tag ("safe", "finalized", "latest", or "ignore" to ignore this check) */ - 'l1-block-bound'?: string; - /** post batches even if not within the layer 1 future bounds if we're within this margin of the max delay (default 1h0m0s) */ - 'l1-block-bound-bypass'?: string; - /** maximum 4844 blob enabled batch size (default 779288) */ - 'max-4844-batch-size'?: number; - /** maximum batch posting delay (default 1h0m0s) */ - 'max-delay'?: string; - /** maximum batch size (default 100000) */ - 'max-size'?: number; - 'parent-chain-wallet'?: { - /** account to use (default is first account in keystore) */ - 'account'?: string; - /** if true, creates new key then exits */ - 'only-create-key'?: boolean; - /** wallet passphrase (default "PASSWORD_NOT_SET") */ - 'password'?: string; - /** pathname for wallet (default "batch-poster-wallet") */ - 'pathname'?: string; - /** private key for wallet */ - 'private-key'?: string; - }; - /** how long to wait after no batches are ready to be posted before checking again (default 10s) */ - 'poll-interval'?: string; - /** if the parent chain supports 4844 blobs and they're well priced, post EIP-4844 blobs */ - 'post-4844-blobs'?: boolean; - 'redis-lock'?: { - /** should node always try grabing lock in background */ - 'background-lock'?: boolean; - /** if false, always treat this as locked and don't write the lock to redis (default true) */ - 'enable'?: boolean; - /** key for lock */ - 'key'?: string; - /** how long lock is held (default 1m0s) */ - 'lockout-duration'?: string; - /** this node's id prefix when acquiring the lock (optional) */ - 'my-id'?: string; - /** how long between consecutive calls to redis (default 10s) */ - 'refresh-duration'?: string; - }; - /** if non-empty, the Redis URL to store queued transactions in */ - 'redis-url'?: string; - /** post batches with access lists to reduce gas usage (disabled for L3s) (default true) */ - 'use-access-lists'?: boolean; - /** wait for the max batch delay, even if the batch is full */ - 'wait-for-max-delay'?: boolean; - }; - 'block-validator'?: { - /** current wasm module root ('current' read from chain, 'latest' from machines/latest dir, or provide hash) (default "current") */ - 'current-module-root'?: string; - 'dangerous'?: { - /** resets block-by-block validation, starting again at genesis */ - 'reset-block-validation'?: boolean; - }; - /** enable block-by-block validation */ - 'enable'?: boolean; - /** failing a validation is treated as a fatal error (default true) */ - 'failure-is-fatal'?: boolean; - /** prepare entries for up to that many blocks ahead of validation (small footprint) (default 1024) */ - 'forward-blocks'?: number; - /** minimum free-memory limit after reaching which the blockvalidator pauses validation. Enabled by default as 1GB, to disable provide empty string (default "default") */ - 'memory-free-limit'?: string; - /** pending upgrade wasm module root to additionally validate (hash, 'latest' or empty) (default "latest") */ - 'pending-upgrade-module-root'?: string; - /** record that many blocks ahead of validation (larger footprint) (default 24) */ - 'prerecorded-blocks'?: number; - /** poll time to check validations (default 1s) */ - 'validation-poll'?: string; - /** array of validation rpc configs given as a json string. time duration should be supplied in number indicating nanoseconds (default "default") */ - 'validation-server-configs-list'?: string; - 'validation-server'?: { - /** limit size of arguments in log entries (default 2048) */ - 'arg-log-limit'?: number; - /** how long to wait for initial connection */ - 'connection-wait'?: string; - /** path to file with jwtsecret for validation - ignored if url is self or self-auth */ - 'jwtsecret'?: string; - /** number of retries in case of failure(0 mean one attempt) (default 3) */ - 'retries'?: number; - /** delay between retries */ - 'retry-delay'?: string; - /** Errors matching this regular expression are automatically retried (default "websocket: close.*|dial tcp .*|.*i/o timeout|.*connection reset by peer|.*connection refused") */ - 'retry-errors'?: string; - /** per-response timeout (0-disabled) */ - 'timeout'?: string; - /** url of server, use self for loopback websocket, self-auth for loopback with authentication (default "self-auth") */ - 'url'?: string; - }; - }; - 'dangerous'?: { - /** DANGEROUS! disables the EIP-4844 blob reader, which is necessary to read batches */ - 'disable-blob-reader'?: boolean; - /** DANGEROUS! disables listening to L1. To be used in test nodes only */ - 'no-l1-listener'?: boolean; - /** DANGEROUS! allows sequencing without sequencer-coordinator */ - 'no-sequencer-coordinator'?: boolean; - }; - 'data-availability'?: { - /** enable Anytrust Data Availability mode */ - 'enable'?: boolean; - 'ipfs-storage'?: { - /** enable storage/retrieval of sequencer batch data from IPFS */ - 'enable'?: boolean; - /** list of IPFS peers to connect to, eg /ip4/1.2.3.4/tcp/12345/p2p/abc...xyz */ - 'peers'?: string[]; - /** pin sequencer batch data in IPFS (default true) */ - 'pin-after-get'?: boolean; - /** percent of sequencer batch data to pin, as a floating point number in the range 0.0 to 100.0 (default 100) */ - 'pin-percentage'?: number; - /** comma separated list of IPFS profiles to use, see https://docs.ipfs.tech/how-to/default-profile */ - 'profiles'?: string; - /** timeout for IPFS reads, since by default it will wait forever. Treat timeout as not found (default 1m0s) */ - 'read-timeout'?: string; - /** directory to use to store the local IPFS repo */ - 'repo-dir'?: string; - }; - /** whether the Data Availability Service should fail immediately on errors (not recommended) */ - 'panic-on-error'?: boolean; - /** parent chain RPC connection attempts (spaced out at least 1 second per attempt, 0 to retry infinitely), only used in standalone daserver; when running as part of a node that node's parent chain configuration is used (default 15) */ - 'parent-chain-connection-attempts'?: number; - /** URL for parent chain node, only used in standalone daserver; when running as part of a node that node's L1 configuration is used */ - 'parent-chain-node-url'?: string; - /** Data Availability Service timeout duration for Store requests (default 5s) */ - 'request-timeout'?: string; - 'rest-aggregator'?: { - /** enable retrieval of sequencer batch data from a list of remote REST endpoints; if other DAS storage types are enabled, this mode is used as a fallback */ - 'enable'?: boolean; - /** number of stats entries (latency and success rate) to keep for each REST endpoint; controls whether strategy is faster or slower to respond to changing conditions (default 20) */ - 'max-per-endpoint-stats'?: number; - /** a URL to a list of URLs of REST das endpoints that is checked at startup; additive with the url option */ - 'online-url-list'?: string; - /** time interval to periodically fetch url list from online-url-list (default 1h0m0s) */ - 'online-url-list-fetch-interval'?: string; - 'simple-explore-exploit-strategy'?: { - /** number of consecutive GetByHash calls to the aggregator where each call will cause it to select from REST endpoints in order of best latency and success rate, before switching to explore mode (default 1000) */ - 'exploit-iterations'?: number; - /** number of consecutive GetByHash calls to the aggregator where each call will cause it to randomly select from REST endpoints until one returns successfully, before switching to exploit mode (default 20) */ - 'explore-iterations'?: number; - }; - /** strategy to use to determine order and parallelism of calling REST endpoint URLs; valid options are 'simple-explore-exploit' (default "simple-explore-exploit") */ - 'strategy'?: string; - /** how frequently to update the strategy with endpoint latency and error rate data (default 10s) */ - 'strategy-update-interval'?: string; - 'sync-to-storage'?: { - /** check if the data already exists in this DAS's storage. Must be disabled for fast sync with an IPFS backend (default true) */ - 'check-already-exists'?: boolean; - /** time to wait if encountered an error before retrying (default 1s) */ - 'delay-on-error'?: string; - /** eagerly sync batch data to this DAS's storage from the rest endpoints, using L1 as the index of batch data hashes; otherwise only sync lazily */ - 'eager'?: boolean; - /** when eagerly syncing, start indexing forward from this L1 block. Only used if there is no sync state */ - 'eager-lower-bound-block'?: number; - /** log only on failures to write when syncing; otherwise treat it as an error (default true) */ - 'ignore-write-errors'?: boolean; - /** when eagerly syncing, max l1 blocks to read per poll (default 100) */ - 'parent-chain-blocks-per-read'?: number; - /** period to retain synced data (defaults to forever) (default 2562047h47m16.854775807s) */ - 'retention-period'?: string; - /** directory to store the sync state in, ie the block number currently synced up to, so that we don't sync from scratch each time */ - 'state-dir'?: string; - }; - /** list of URLs including 'http://' or 'https://' prefixes and port numbers to REST DAS endpoints; additive with the online-url-list option */ - 'urls'?: string[]; - /** time to wait until trying the next set of REST endpoints while waiting for a response; the next set of REST endpoints is determined by the strategy selected (default 2s) */ - 'wait-before-try-next'?: string; - }; - 'rpc-aggregator'?: { - /** Number of assumed honest backends (H). If there are N backends, K=N+1-H valid responses are required to consider an Store request to be successful. */ - 'assumed-honest'?: number; - /** JSON RPC backend configuration */ - 'backends'?: string; - /** enable storage/retrieval of sequencer batch data from a list of RPC endpoints; this should only be used by the batch poster and not in combination with other DAS storage types */ - 'enable'?: boolean; - }; - /** parent chain address of SequencerInbox contract */ - 'sequencer-inbox-address'?: string; - }; - 'delayed-sequencer'?: { - /** enable delayed sequencer */ - 'enable'?: boolean; - /** how many blocks in the past L1 block is considered final (ignored when using Merge finality) (default 20) */ - 'finalize-distance'?: number; - /** whether to wait for full finality before sequencing delayed messages */ - 'require-full-finality'?: boolean; - /** whether to use The Merge's notion of finality before sequencing delayed messages (default true) */ - 'use-merge-finality'?: boolean; - }; - 'feed'?: { - input?: { - /** enable per message deflate compression support (default true) */ - 'enable-compression'?: boolean; - /** initial duration to wait before reconnect (default 1s) */ - 'reconnect-initial-backoff'?: string; - /** maximum duration to wait before reconnect (default 1m4s) */ - 'reconnect-maximum-backoff'?: string; - /** require chain id to be present on connect */ - 'require-chain-id'?: boolean; - /** require feed version to be present on connect */ - 'require-feed-version'?: boolean; - /** list of secondary URLs of sequencer feed source. Would be started in the order they appear in the list when primary feeds fails */ - 'secondary-url'?: string[]; - /** duration to wait before timing out connection to sequencer feed (default 20s) */ - 'timeout'?: string; - /** list of primary URLs of sequencer feed source */ - 'url'?: string[]; - 'verify'?: { - /** accept verified message from sequencer (default true) */ - 'accept-sequencer'?: boolean; - /** a list of allowed addresses */ - 'allowed-addresses'?: string[]; - 'dangerous'?: { - /** accept empty as valid signature (default true) */ - 'accept-missing'?: boolean; - }; - }; - }; - output?: { - /** address to bind the relay feed output to */ - 'addr'?: string; - 'backlog'?: { - /** the maximum number of messages each segment within the backlog can contain (default 240) */ - 'segment-limit'?: number; - }; - /** delay the first messages sent to each client by this amount */ - 'client-delay'?: string; - /** duration to wait before timing out connections to client (default 15s) */ - 'client-timeout'?: string; - 'connection-limits'?: { - /** enable broadcaster per-client connection limiting */ - 'enable'?: boolean; - /** limit clients, as identified by IPv4/v6 address, to this many connections to this relay (default 5) */ - 'per-ip-limit'?: number; - /** limit ipv6 clients, as identified by IPv6 address masked with /48, to this many connections to this relay (default 20) */ - 'per-ipv6-cidr-48-limit'?: number; - /** limit ipv6 clients, as identified by IPv6 address masked with /64, to this many connections to this relay (default 10) */ - 'per-ipv6-cidr-64-limit'?: number; - /** time to wait after a relay client disconnects before the disconnect is registered with respect to the limit for this client */ - 'reconnect-cooldown-period'?: string; - }; - /** don't sign feed messages (default true) */ - 'disable-signing'?: boolean; - /** enable broadcaster */ - 'enable'?: boolean; - /** enable per message deflate compression support */ - 'enable-compression'?: boolean; - /** duration to wait before timing out HTTP to WS upgrade (default 1s) */ - 'handshake-timeout'?: string; - /** only supply catchup buffer if requested sequence number is reasonable */ - 'limit-catchup'?: boolean; - /** log every client connect */ - 'log-connect'?: boolean; - /** log every client disconnect */ - 'log-disconnect'?: boolean; - /** the maximum size of the catchup buffer (-1 means unlimited) (default -1) */ - 'max-catchup'?: number; - /** maximum number of messages allowed to accumulate before client is disconnected (default 4096) */ - 'max-send-queue'?: number; - /** duration for ping interval (default 5s) */ - 'ping'?: string; - /** port to bind the relay feed output to (default "9642") */ - 'port'?: string; - /** queue size for HTTP to WS upgrade (default 100) */ - 'queue'?: number; - /** duration to wait before timing out reading data (i.e. pings) from clients (default 1s) */ - 'read-timeout'?: string; - /** require clients to use compression */ - 'require-compression'?: boolean; - /** don't connect if client version not present */ - 'require-version'?: boolean; - /** sign broadcast messages */ - 'signed'?: boolean; - /** number of threads to reserve for HTTP to WS upgrade (default 100) */ - 'workers'?: number; - /** duration to wait before timing out writing data to clients (default 2s) */ - 'write-timeout'?: string; - }; - }; - 'inbox-reader'?: { - /** the maximum time to wait between inbox checks (if not enough new blocks are found) (default 1m0s) */ - 'check-delay'?: string; - /** the default number of blocks to read at once (will vary based on traffic by default) (default 100) */ - 'default-blocks-to-read'?: number; - /** number of latest blocks to ignore to reduce reorgs */ - 'delay-blocks'?: number; - /** erase future transactions in addition to overwriting existing ones on reorg */ - 'hard-reorg'?: boolean; - /** if adjust-blocks-to-read is enabled, the maximum number of blocks to read at once (default 2000) */ - 'max-blocks-to-read'?: number; - /** the minimum number of blocks to read at once (when caught up lowers load on L1) (default 1) */ - 'min-blocks-to-read'?: number; - /** mode to only read latest or safe or finalized L1 blocks. Enabling safe or finalized disables feed input and output. Defaults to latest. Takes string input, valid strings- latest, safe, finalized (default "latest") */ - 'read-mode'?: string; - /** if adjust-blocks-to-read is enabled, the target number of messages to read at once (default 500) */ - 'target-messages-read'?: number; - }; - 'maintenance'?: { - 'lock'?: { - /** should node always try grabing lock in background */ - 'background-lock'?: boolean; - /** if false, always treat this as locked and don't write the lock to redis (default true) */ - 'enable'?: boolean; - /** key for lock */ - 'key'?: string; - /** how long lock is held (default 1m0s) */ - 'lockout-duration'?: string; - /** this node's id prefix when acquiring the lock (optional) */ - 'my-id'?: string; - /** how long between consecutive calls to redis (default 10s) */ - 'refresh-duration'?: string; - }; - /** UTC 24-hour time of day to run maintenance (currently only db compaction) at (e.g. 15:00) */ - 'time-of-day'?: string; - }; - 'message-pruner'?: { - /** enable message pruning (default true) */ - 'enable'?: boolean; - /** min number of batches not pruned (default 2) */ - 'min-batches-left'?: number; - /** interval for running message pruner (default 1m0s) */ - 'prune-interval'?: string; - }; - 'parent-chain-reader'?: { - 'dangerous'?: { - /** Dangerous! only meant to be used by system tests */ - 'wait-for-tx-approval-safe-poll'?: string; - }; - /** enable reader connection (default true) */ - 'enable'?: boolean; - /** warns if the latest l1 block is at least this old (default 5m0s) */ - 'old-header-timeout'?: string; - /** interval when polling endpoint (default 15s) */ - 'poll-interval'?: string; - /** do not attempt to subscribe to header events */ - 'poll-only'?: boolean; - /** interval for subscribe error (default 5m0s) */ - 'subscribe-err-interval'?: string; - /** timeout when waiting for a transaction (default 5m0s) */ - 'tx-timeout'?: string; - /** use l1 data about finalized/safe blocks (default true) */ - 'use-finality-data'?: boolean; - }; - 'seq-coordinator'?: { - /** if non-empty, launch an HTTP service binding to this address that returns status code 200 when chosen and 503 otherwise */ - 'chosen-healthcheck-addr'?: string; - /** enable sequence coordinator */ - 'enable'?: boolean; - /** the maximum amount of time to spend waiting for another sequencer to accept the lockout when handing it off on shutdown or db compaction (default 30s) */ - 'handoff-timeout'?: string; - /** (default 1m0s) */ - 'lockout-duration'?: string; - /** (default 30s) */ - 'lockout-spare'?: string; - /** will only be marked as wanting the lockout if not too far behind (default 2000) */ - 'msg-per-poll'?: number; - /** url for this sequencer if it is the chosen (default "") */ - 'my-url'?: string; - /** the Redis URL to coordinate via */ - 'redis-url'?: string; - /** the number of times to retry releasing the wants lockout and chosen one status on shutdown (default 4) */ - 'release-retries'?: number; - /** (default 50ms) */ - 'retry-interval'?: string; - /** if non-zero will add delay after transferring control (default 5s) */ - 'safe-shutdown-delay'?: string; - /** (default 24h0m0s) */ - 'seq-num-duration'?: string; - 'signer'?: { - 'ecdsa'?: { - /** accept verified message from sequencer (default true) */ - 'accept-sequencer'?: boolean; - /** a list of allowed addresses */ - 'allowed-addresses'?: string[]; - 'dangerous'?: { - /** accept empty as valid signature (default true) */ - 'accept-missing'?: boolean; - }; - }; - /** if to fall back to symmetric hmac */ - 'symmetric-fallback'?: boolean; - /** if to sign with symmetric hmac */ - 'symmetric-sign'?: boolean; - 'symmetric'?: { - 'dangerous'?: { - /** disable message signature verification */ - 'disable-signature-verification'?: boolean; - }; - /** a fallback key used for message verification */ - 'fallback-verification-key'?: string; - /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ - 'signing-key'?: string; - }; - }; - /** (default 250ms) */ - 'update-interval'?: string; - }; - /** enable sequencer */ - 'sequencer'?: boolean; - 'staker'?: { - /** confirmation blocks (default 12) */ - 'confirmation-blocks'?: number; - /** validator smart contract wallet public address */ - 'contract-wallet-address'?: string; - 'dangerous'?: { - /** DANGEROUS! make assertions even when the wasm module root is wrong */ - 'ignore-rollup-wasm-module-root'?: boolean; - /** DANGEROUS! allows running an L1 validator without a block validator */ - 'without-block-validator'?: boolean; - }; - 'data-poster'?: { - /** if true, don't put transactions in the mempool that spend a total greater than the batch poster's balance (default true) */ - 'allocate-mempool-balance'?: boolean; - 'dangerous'?: { - /** clear database storage */ - 'clear-dbstorage'?: boolean; - }; - /** unit to measure the time elapsed since creation of transaction used for maximum fee cap calculation (default 10m0s) */ - 'elapsed-time-base'?: string; - /** weight given to the units of time elapsed used for maximum fee cap calculation (default 10) */ - 'elapsed-time-importance'?: number; - 'external-signer'?: { - /** external signer address */ - 'address'?: string; - /** rpc client cert */ - 'client-cert'?: string; - /** rpc client private key */ - 'client-private-key'?: string; - /** external signer method (default "eth_signTransaction") */ - 'method'?: string; - /** external signer root CA */ - 'root-ca'?: string; - /** external signer url */ - 'url'?: string; - }; - /** encodes items in a legacy way (as it was before dropping generics) */ - 'legacy-storage-encoding'?: boolean; - /** mathematical formula to calculate maximum fee cap gwei the result of which would be float64. This expression is expected to be evaluated please refer https://github.com/Knetic/govaluate/blob/master/MANUAL.md to find all available mathematical operators. Currently available variables to construct the formula are BacklogOfBatches, UrgencyGWei, ElapsedTime, ElapsedTimeBase, ElapsedTimeImportance, and TargetPriceGWei (default "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei") */ - 'max-fee-cap-formula'?: string; - /** the maximum number of transactions to have queued in the mempool at once (0 = unlimited) (default 1) */ - 'max-mempool-transactions'?: number; - /** the maximum number of unconfirmed transactions to track at once (0 = unlimited) */ - 'max-queued-transactions'?: number; - /** the maximum tip cap to post transactions at (default 5) */ - 'max-tip-cap-gwei'?: number; - /** the minimum fee cap to post transactions at */ - 'min-fee-cap-gwei'?: number; - /** the minimum tip cap to post transactions at (default 0.05) */ - 'min-tip-cap-gwei'?: number; - /** the maximum probable reorg depth, used to determine when a transaction will no longer likely need replaced-by-fee (default 1) */ - 'nonce-rbf-soft-confs'?: number; - 'redis-signer'?: { - 'dangerous'?: { - /** disable message signature verification */ - 'disable-signature-verification'?: boolean; - }; - /** a fallback key used for message verification */ - 'fallback-verification-key'?: string; - /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ - 'signing-key'?: string; - }; - /** comma-separated list of durations since first posting to attempt a replace-by-fee (default "5m,10m,20m,30m,1h,2h,4h,6h,8h,12h,16h,18h,20h,22h") */ - 'replacement-times'?: string; - /** the target price to use for maximum fee cap calculation (default 60) */ - 'target-price-gwei'?: number; - /** the urgency to use for maximum fee cap calculation (default 2) */ - 'urgency-gwei'?: number; - /** uses database storage when enabled (default true) */ - 'use-db-storage'?: boolean; - /** uses noop storage, it doesn't store anything */ - 'use-noop-storage'?: boolean; - /** only treat a transaction as confirmed after L1 finality has been achieved (recommended) (default true) */ - 'wait-for-l1-finality'?: boolean; - }; - /** disable validator challenge */ - 'disable-challenge'?: boolean; - /** enable validator (default true) */ - 'enable'?: boolean; - /** use this much more gas than estimation says is necessary to post transactions (default 50000) */ - 'extra-gas'?: number; - /** The gas refunder contract address (optional) */ - 'gas-refunder-address'?: string; - /** if configured with the makeNodes strategy, how often to create new assertions (bypassed in case of a dispute) (default 1h0m0s) */ - 'make-assertion-interval'?: string; - /** only create smart wallet contract and exit */ - 'only-create-wallet-contract'?: boolean; - 'parent-chain-wallet'?: { - /** account to use (default is first account in keystore) */ - 'account'?: string; - /** if true, creates new key then exits */ - 'only-create-key'?: boolean; - /** wallet passphrase (default "PASSWORD_NOT_SET") */ - 'password'?: string; - /** pathname for wallet (default "validator-wallet") */ - 'pathname'?: string; - /** private key for wallet */ - 'private-key'?: string; - }; - 'posting-strategy'?: { - /** high gas delay blocks */ - 'high-gas-delay-blocks'?: number; - /** high gas threshold */ - 'high-gas-threshold'?: number; - }; - /** redis url for L1 validator */ - 'redis-url'?: string; - /** how often the L1 validator should check the status of the L1 rollup and maybe take action with its stake (default 1m0s) */ - 'staker-interval'?: string; - /** assume staked nodes are valid (default true) */ - 'start-validation-from-staked'?: boolean; - /** L1 validator strategy, either watchtower, defensive, stakeLatest, or makeNodes (default "Watchtower") */ - 'strategy'?: string; - /** use a smart contract wallet instead of an EOA address */ - 'use-smart-contract-wallet'?: boolean; - }; - 'sync-monitor'?: { - /** allowed lag between messages read and blocks built (default 20) */ - 'block-build-lag'?: number; - /** allowed lag between messages read from sequencer inbox and blocks built */ - 'block-build-sequencer-inbox-lag'?: number; - /** allowed lag between local and remote messages (default 15) */ - 'coordinator-msg-lag'?: number; - /** wait for block validator to complete before returning finalized block number */ - 'finalized-block-wait-for-block-validator'?: boolean; - /** wait for block validator to complete before returning safe block number */ - 'safe-block-wait-for-block-validator'?: boolean; - }; - 'transaction-streamer'?: { - /** delay when polling calls to execute messages (default 100ms) */ - 'execute-message-loop-delay'?: string; - /** maximum cache of pending broadcaster messages (default 50000) */ - 'max-broadcaster-queue-size'?: number; - /** maximum number of messages to attempt to resequence on reorg (0 = never resequence, -1 = always resequence) (default 1024) */ - 'max-reorg-resequence-depth'?: number; - }; - }; - 'p2p'?: { - /** P2P bootnodes */ - 'bootnodes'?: string[]; - /** P2P bootnodes v5 */ - 'bootnodes-v5'?: string[]; - /** P2P discovery v4 */ - 'discovery-v4'?: boolean; - /** P2P discovery v5 */ - 'discovery-v5'?: boolean; - /** P2P listen address */ - 'listen-addr'?: string; - /** P2P max peers (default 50) */ - 'max-peers'?: number; - /** P2P no dial (default true) */ - 'no-dial'?: boolean; - /** P2P no discovery (default true) */ - 'no-discovery'?: boolean; - }; - 'parent-chain'?: { - 'blob-client'?: { - /** Beacon Chain RPC URL to use for fetching blobs (normally on port 3500) */ - 'beacon-url'?: string; - /** Full path of the directory to save fetched blobs */ - 'blob-directory'?: string; - }; - 'connection'?: { - /** limit size of arguments in log entries (default 2048) */ - 'arg-log-limit'?: number; - /** how long to wait for initial connection (default 1m0s) */ - 'connection-wait'?: string; - /** path to file with jwtsecret for validation - ignored if url is self or self-auth */ - 'jwtsecret'?: string; - /** number of retries in case of failure(0 mean one attempt) (default 2) */ - 'retries'?: number; - /** delay between retries */ - 'retry-delay'?: string; - /** Errors matching this regular expression are automatically retried */ - 'retry-errors'?: string; - /** per-response timeout (0-disabled) (default 1m0s) */ - 'timeout'?: string; - /** url of server, use self for loopback websocket, self-auth for loopback with authentication */ - 'url'?: string; - }; - /** if set other than 0, will be used to validate database and L1 connection */ - 'id'?: number; - 'wallet'?: { - /** account to use (default is first account in keystore) */ - 'account'?: string; - /** if true, creates new key then exits */ - 'only-create-key'?: boolean; - /** wallet passphrase (default "PASSWORD_NOT_SET") */ - 'password'?: string; - /** pathname for wallet (default "wallet") */ - 'pathname'?: string; - /** private key for wallet */ - 'private-key'?: string; - }; - }; - 'persistent'?: { - /** directory of ancient where the chain freezer can be opened */ - 'ancient'?: string; - /** directory to store chain state */ - 'chain'?: string; - /** backing database implementation to use ('leveldb' or 'pebble') (default "leveldb") */ - 'db-engine'?: string; - /** directory to store global config (default ".arbitrum") */ - 'global-config'?: string; - /** number of file descriptor handles to use for the database (default 512) */ - 'handles'?: number; - /** directory to store log file */ - 'log-dir'?: string; - }; - /** enable pprof */ - 'pprof'?: boolean; - 'pprof-cfg'?: { - /** pprof server address (default "127.0.0.1") */ - addr?: string; - /** pprof server port (default 6071) */ - port?: number; - }; - 'rpc'?: { - /** the maximum number of requests in a batch (0 means no limit) (default 1000) */ - 'batch-request-limit'?: number; - /** the maximum response size for a JSON-RPC request measured in bytes (0 means no limit) (default 10000000) */ - 'max-batch-response-size'?: number; - }; - 'validation'?: { - /** validate is an authenticated API (default true) */ - 'api-auth'?: boolean; - /** validate is a public API */ - 'api-public'?: boolean; - 'arbitrator'?: { - /** timeout before discarding execution run (default 15m0s) */ - 'execution-run-timeout'?: string; - 'execution'?: { - /** how many machines to store in cache while working on a challenge (should be even) (default 4) */ - 'cached-challenge-machines'?: number; - /** initial steps between machines (default 100000) */ - 'initial-steps'?: number; - }; - /** path to write machines to (default "./target/output") */ - 'output-path'?: string; - /** number of concurrent validation threads */ - 'workers'?: number; - }; - 'jit'?: { - /** use Cranelift instead of LLVM when validating blocks using the jit-accelerated block validator (default true) */ - 'cranelift'?: boolean; - /** if memory used by a jit wasm exceeds this limit, a warning is logged (default 4294967296) */ - 'wasm-memory-usage-limit'?: number; - /** number of concurrent validation threads */ - 'workers'?: number; - }; - /** use jit for validation (default true) */ - 'use-jit'?: boolean; - 'wasm'?: { - /** list of WASM module roots to check if the on-chain WASM module root belongs to on node startup */ - 'allowed-wasm-module-roots'?: string[]; - /** enable check for compatibility of on-chain WASM module root with node (default true) */ - 'enable-wasmroots-check'?: boolean; - /** path to machine folders, each containing wasm files (machine.wavm.br, replay.wasm) */ - 'root-path'?: string; - }; - }; - 'ws'?: { - /** WS-RPC server listening interface */ - 'addr'?: string; - /** APIs offered over the WS-RPC interface (default [net,web3,eth,arb]) */ - 'api'?: string[]; - /** expose private api via websocket */ - 'expose-all'?: boolean; - /** Origins from which to accept websockets requests */ - 'origins'?: string[]; - /** WS-RPC server listening port (default 8548) */ - 'port'?: number; - /** WS path path prefix on which JSON-RPC is served. Use '/' to serve on all paths */ - 'rpcprefix'?: string; - }; -}; -/** Union type for all Nitro node configuration options */ -export type NodeConfigOption = - | { - /** AUTH-RPC server listening interface (default "127.0.0.1") */ - key: 'auth.addr'; - type: string; - } - | { - /** APIs offered over the AUTH-RPC interface (default [validation]) */ - key: 'auth.api'; - type: string[]; - } - | { - /** Path to file holding JWT secret (32B hex) */ - key: 'auth.jwtsecret'; - type: string; - } - | { - /** Origins from which to accept AUTH requests (default [localhost]) */ - key: 'auth.origins'; - type: string[]; - } - | { - /** AUTH-RPC server listening port (default 8549) */ - key: 'auth.port'; - type: number; - } - | { - /** minimum number of blocks to execute per thread. When mode is random this acts as the size of random block range sample (default 10000) */ - key: 'blocks-reexecutor.blocks-per-thread'; - type: number; - } - | { - /** enables re-execution of a range of blocks against historic state */ - key: 'blocks-reexecutor.enable'; - type: boolean; - } - | { - /** last block number of the block range for re-execution */ - key: 'blocks-reexecutor.end-block'; - type: number; - } - | { - /** mode to run the blocks-reexecutor on. Valid modes full and random. full - execute all the blocks in the given range. random - execute a random sample range of blocks with in a given range (default "random") */ - key: 'blocks-reexecutor.mode'; - type: string; - } - | { - /** number of threads to parallelize blocks re-execution (default 12) */ - key: 'blocks-reexecutor.room'; - type: number; - } - | { - /** first block number of the block range for re-execution */ - key: 'blocks-reexecutor.start-block'; - type: number; - } - | { - /** account to use (default is first account in keystore) */ - key: 'chain.dev-wallet.account'; - type: string; - } - | { - /** if true, creates new key then exits */ - key: 'chain.dev-wallet.only-create-key'; - type: boolean; - } - | { - /** wallet passphrase (default "PASSWORD_NOT_SET") */ - key: 'chain.dev-wallet.password'; - type: string; - } - | { - /** pathname for wallet */ - key: 'chain.dev-wallet.pathname'; - type: string; - } - | { - /** private key for wallet */ - key: 'chain.dev-wallet.private-key'; - type: string; - } - | { - /** L2 chain ID (determines Arbitrum network) */ - key: 'chain.id'; - type: number; - } - | { - /** L2 chain info json files */ - key: 'chain.info-files'; - type: string[]; - } - | { - /** path to save temp downloaded file (default "/tmp/") */ - key: 'chain.info-ipfs-download-path'; - type: string; - } - | { - /** url to download chain info file */ - key: 'chain.info-ipfs-url'; - type: string; - } - | { - /** L2 chain info in json string format */ - key: 'chain.info-json'; - type: string; - } - | { - /** L2 chain name (determines Arbitrum network) */ - key: 'chain.name'; - type: string; - } - | { - /** print out currently active configuration file */ - key: 'conf.dump'; - type: boolean; - } - | { - /** environment variables with given prefix will be loaded as configuration values */ - key: 'conf.env-prefix'; - type: string; - } - | { - /** name of configuration file */ - key: 'conf.file'; - type: string[]; - } - | { - /** how often to reload configuration (0=disable periodic reloading) */ - key: 'conf.reload-interval'; - type: string; - } - | { - /** S3 access key */ - key: 'conf.s3.access-key'; - type: string; - } - | { - /** S3 bucket */ - key: 'conf.s3.bucket'; - type: string; - } - | { - /** S3 object key */ - key: 'conf.s3.object-key'; - type: string; - } - | { - /** S3 region */ - key: 'conf.s3.region'; - type: string; - } - | { - /** S3 secret key */ - key: 'conf.s3.secret-key'; - type: string; - } - | { - /** configuration as JSON string */ - key: 'conf.string'; - type: string; - } - | { - /** retain past block state */ - key: 'execution.caching.archive'; - type: boolean; - } - | { - /** minimum age of recent blocks to keep in memory (default 30m0s) */ - key: 'execution.caching.block-age'; - type: string; - } - | { - /** minimum number of recent blocks to keep in memory (default 128) */ - key: 'execution.caching.block-count'; - type: number; - } - | { - /** amount of memory in megabytes to cache database contents with (default 2048) */ - key: 'execution.caching.database-cache'; - type: number; - } - | { - /** maximum amount of gas in blocks to skip saving state to Persistent storage (archive node only) -- warning: this option seems to cause issues */ - key: 'execution.caching.max-amount-of-gas-to-skip-state-saving'; - type: number; - } - | { - /** maximum number of blocks to skip state saving to persistent storage (archive node only) -- warning: this option seems to cause issues */ - key: 'execution.caching.max-number-of-blocks-to-skip-state-saving'; - type: number; - } - | { - /** amount of memory in megabytes to cache state snapshots with (default 400) */ - key: 'execution.caching.snapshot-cache'; - type: number; - } - | { - /** maximum gas rolled back to recover snapshot (default 300000000000) */ - key: 'execution.caching.snapshot-restore-gas-limit'; - type: number; - } - | { - /** amount of memory in megabytes to cache unchanged state trie nodes with (default 600) */ - key: 'execution.caching.trie-clean-cache'; - type: number; - } - | { - /** amount of memory in megabytes to cache state diffs against disk with (larger cache lowers database growth) (default 1024) */ - key: 'execution.caching.trie-dirty-cache'; - type: number; - } - | { - /** maximum block processing time before trie is written to hard-disk (default 1h0m0s) */ - key: 'execution.caching.trie-time-limit'; - type: string; - } - | { - /** DANGEROUS! forces a reorg to an old block height. To be used for testing only. -1 to disable (default -1) */ - key: 'execution.dangerous.reorg-to-block'; - type: number; - } - | { - /** enable prefetching of blocks (default true) */ - key: 'execution.enable-prefetch-block'; - type: boolean; - } - | { - /** total time to wait before cancelling connection (default 30s) */ - key: 'execution.forwarder.connection-timeout'; - type: string; - } - | { - /** time until idle connections are closed (default 15s) */ - key: 'execution.forwarder.idle-connection-timeout'; - type: string; - } - | { - /** maximum number of idle connections to keep open (default 1) */ - key: 'execution.forwarder.max-idle-connections'; - type: number; - } - | { - /** the Redis URL to recomend target via */ - key: 'execution.forwarder.redis-url'; - type: string; - } - | { - /** minimal time between update retries (default 100ms) */ - key: 'execution.forwarder.retry-interval'; - type: string; - } - | { - /** forwarding target update interval (default 1s) */ - key: 'execution.forwarder.update-interval'; - type: string; - } - | { - /** transaction forwarding target URL, or "null" to disable forwarding (iff not sequencer) */ - key: 'execution.forwarding-target'; - type: string; - } - | { - /** Dangerous! only meant to be used by system tests */ - key: 'execution.parent-chain-reader.dangerous.wait-for-tx-approval-safe-poll'; - type: string; - } - | { - /** enable reader connection (default true) */ - key: 'execution.parent-chain-reader.enable'; - type: boolean; - } - | { - /** warns if the latest l1 block is at least this old (default 5m0s) */ - key: 'execution.parent-chain-reader.old-header-timeout'; - type: string; - } - | { - /** interval when polling endpoint (default 15s) */ - key: 'execution.parent-chain-reader.poll-interval'; - type: string; - } - | { - /** do not attempt to subscribe to header events */ - key: 'execution.parent-chain-reader.poll-only'; - type: boolean; - } - | { - /** interval for subscribe error (default 5m0s) */ - key: 'execution.parent-chain-reader.subscribe-err-interval'; - type: string; - } - | { - /** timeout when waiting for a transaction (default 5m0s) */ - key: 'execution.parent-chain-reader.tx-timeout'; - type: string; - } - | { - /** use l1 data about finalized/safe blocks (default true) */ - key: 'execution.parent-chain-reader.use-finality-data'; - type: boolean; - } - | { - /** like trie-clean-cache for the separate, recording database (used for validation) (default 16) */ - key: 'execution.recording-database.trie-clean-cache'; - type: number; - } - | { - /** like trie-dirty-cache for the separate, recording database (used for validation) (default 1024) */ - key: 'execution.recording-database.trie-dirty-cache'; - type: number; - } - | { - /** list of whitelisted rpc methods */ - key: 'execution.rpc.allow-method'; - type: string[]; - } - | { - /** bounds the number of blocks arbdebug calls may return (default 256) */ - key: 'execution.rpc.arbdebug.block-range-bound'; - type: number; - } - | { - /** bounds the length of timeout queues arbdebug calls may return (default 512) */ - key: 'execution.rpc.arbdebug.timeout-queue-bound'; - type: number; - } - | { - /** number of blocks a single bloom bit section vector holds (default 16384) */ - key: 'execution.rpc.bloom-bits-blocks'; - type: number; - } - | { - /** number of confirmation blocks before a bloom section is considered final (default 256) */ - key: 'execution.rpc.bloom-confirms'; - type: number; - } - | { - /** url to redirect classic requests, use "error:[CODE:]MESSAGE" to return specified error instead of redirecting */ - key: 'execution.rpc.classic-redirect'; - type: string; - } - | { - /** timeout for forwarded classic requests, where 0 = no timeout */ - key: 'execution.rpc.classic-redirect-timeout'; - type: string; - } - | { - /** timeout used for eth_call (0=infinite) (default 5s) */ - key: 'execution.rpc.evm-timeout'; - type: string; - } - | { - /** max number of blocks a fee history request may cover (default 1024) */ - key: 'execution.rpc.feehistory-max-block-count'; - type: number; - } - | { - /** log filter system maximum number of cached blocks (default 32) */ - key: 'execution.rpc.filter-log-cache-size'; - type: number; - } - | { - /** log filter system maximum time filters stay active (default 5m0s) */ - key: 'execution.rpc.filter-timeout'; - type: string; - } - | { - /** cap on computation gas that can be used in eth_call/estimateGas (0=infinite) (default 50000000) */ - key: 'execution.rpc.gas-cap'; - type: number; - } - | { - /** maximum depth for recreating state, measured in l2 gas (0=don't recreate state, -1=infinite, -2=use default value for archive or non-archive node (whichever is configured)) (default -2) */ - key: 'execution.rpc.max-recreate-state-depth'; - type: number; - } - | { - /** allow transactions that aren't EIP-155 replay protected to be submitted over the RPC (default true) */ - key: 'execution.rpc.tx-allow-unprotected'; - type: boolean; - } - | { - /** cap on transaction fee (in ether) that can be sent via the RPC APIs (0 = no cap) (default 1) */ - key: 'execution.rpc.tx-fee-cap'; - type: number; - } - | { - /** secondary transaction forwarding target URL */ - key: 'execution.secondary-forwarding-target'; - type: string[]; - } - | { - /** act and post to l1 as sequencer */ - key: 'execution.sequencer.enable'; - type: boolean; - } - | { - /** total time to wait before cancelling connection (default 30s) */ - key: 'execution.sequencer.forwarder.connection-timeout'; - type: string; - } - | { - /** time until idle connections are closed (default 1m0s) */ - key: 'execution.sequencer.forwarder.idle-connection-timeout'; - type: string; - } - | { - /** maximum number of idle connections to keep open (default 100) */ - key: 'execution.sequencer.forwarder.max-idle-connections'; - type: number; - } - | { - /** the Redis URL to recomend target via */ - key: 'execution.sequencer.forwarder.redis-url'; - type: string; - } - | { - /** minimal time between update retries (default 100ms) */ - key: 'execution.sequencer.forwarder.retry-interval'; - type: string; - } - | { - /** forwarding target update interval (default 1s) */ - key: 'execution.sequencer.forwarder.update-interval'; - type: string; - } - | { - /** maximum acceptable time difference between the local time and the latest L1 block's timestamp (default 1h0m0s) */ - key: 'execution.sequencer.max-acceptable-timestamp-delta'; - type: string; - } - | { - /** minimum delay between blocks (sets a maximum speed of block production) (default 250ms) */ - key: 'execution.sequencer.max-block-speed'; - type: string; - } - | { - /** maximum gas executed in a revert for the sequencer to reject the transaction instead of posting it (anti-DOS) (default 31000) */ - key: 'execution.sequencer.max-revert-gas-reject'; - type: number; - } - | { - /** maximum transaction size the sequencer will accept (default 95000) */ - key: 'execution.sequencer.max-tx-data-size'; - type: number; - } - | { - /** size of the tx sender nonce cache (default 1024) */ - key: 'execution.sequencer.nonce-cache-size'; - type: number; - } - | { - /** maximum amount of time to wait for a predecessor before rejecting a tx with nonce too high (default 1s) */ - key: 'execution.sequencer.nonce-failure-cache-expiry'; - type: string; - } - | { - /** number of transactions with too high of a nonce to keep in memory while waiting for their predecessor (default 1024) */ - key: 'execution.sequencer.nonce-failure-cache-size'; - type: number; - } - | { - /** size of the pending tx queue (default 1024) */ - key: 'execution.sequencer.queue-size'; - type: number; - } - | { - /** maximum amount of time transaction can wait in queue (default 12s) */ - key: 'execution.sequencer.queue-timeout'; - type: string; - } - | { - /** comma separated whitelist of authorized senders (if empty, everyone is allowed) */ - key: 'execution.sequencer.sender-whitelist'; - type: string; - } - | { - /** retain the ability to lookup transactions by hash for the past N blocks (0 = all blocks) (default 126230400) */ - key: 'execution.tx-lookup-limit'; - type: number; - } - | { - /** how long ago should the storage conditions from eth_SendRawTransactionConditional be true, 0 = don't check old state (default 2) */ - key: 'execution.tx-pre-checker.required-state-age'; - type: number; - } - | { - /** maximum number of blocks to look back while looking for the seconds old state, 0 = don't limit the search (default 4) */ - key: 'execution.tx-pre-checker.required-state-max-blocks'; - type: number; - } - | { - /** how strict to be when checking txs before forwarding them. 0 = accept anything, 10 = should never reject anything that'd succeed, 20 = likely won't reject anything that'd succeed, 30 = full validation which may reject txs that would succeed */ - key: 'execution.tx-pre-checker.strictness'; - type: number; - } - | { - /** size of intermediate log records buffer (default 512) */ - key: 'file-logging.buf-size'; - type: number; - } - | { - /** enable compression of old log files (default true) */ - key: 'file-logging.compress'; - type: boolean; - } - | { - /** enable logging to file (default true) */ - key: 'file-logging.enable'; - type: boolean; - } - | { - /** path to log file (default "nitro.log") */ - key: 'file-logging.file'; - type: string; - } - | { - /** if true: local time will be used in old log filename timestamps */ - key: 'file-logging.local-time'; - type: boolean; - } - | { - /** maximum number of days to retain old log files based on the timestamp encoded in their filename (0 = no limit) */ - key: 'file-logging.max-age'; - type: number; - } - | { - /** maximum number of old log files to retain (0 = no limit) (default 20) */ - key: 'file-logging.max-backups'; - type: number; - } - | { - /** log file size in Mb that will trigger log file rotation (0 = trigger disabled) (default 5) */ - key: 'file-logging.max-size'; - type: number; - } - | { - /** Comma separated list of domains from which to accept cross origin requests (browser enforced) */ - key: 'graphql.corsdomain'; - type: string[]; - } - | { - /** Enable graphql endpoint on the rpc endpoint */ - key: 'graphql.enable'; - type: boolean; - } - | { - /** Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard (default [localhost]) */ - key: 'graphql.vhosts'; - type: string[]; - } - | { - /** HTTP-RPC server listening interface */ - key: 'http.addr'; - type: string; - } - | { - /** APIs offered over the HTTP-RPC interface (default [net,web3,eth,arb]) */ - key: 'http.api'; - type: string[]; - } - | { - /** Comma separated list of domains from which to accept cross origin requests (browser enforced) */ - key: 'http.corsdomain'; - type: string[]; - } - | { - /** HTTP-RPC server listening port (default 8547) */ - key: 'http.port'; - type: number; - } - | { - /** HTTP path path prefix on which JSON-RPC is served. Use '/' to serve on all paths */ - key: 'http.rpcprefix'; - type: string; - } - | { - /** the maximum amount of time to wait for the next request when keep-alives are enabled (http.Server.IdleTimeout) (default 2m0s) */ - key: 'http.server-timeouts.idle-timeout'; - type: string; - } - | { - /** the amount of time allowed to read the request headers (http.Server.ReadHeaderTimeout) (default 30s) */ - key: 'http.server-timeouts.read-header-timeout'; - type: string; - } - | { - /** the maximum duration for reading the entire request (http.Server.ReadTimeout) (default 30s) */ - key: 'http.server-timeouts.read-timeout'; - type: string; - } - | { - /** the maximum duration before timing out writes of the response (http.Server.WriteTimeout) (default 30s) */ - key: 'http.server-timeouts.write-timeout'; - type: string; - } - | { - /** Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard (default [localhost]) */ - key: 'http.vhosts'; - type: string[]; - } - | { - /** during init - sync database every X accounts. Lower value for low-memory systems. 0 disables. (default 100000) */ - key: 'init.accounts-per-sync'; - type: number; - } - | { - /** init with dev data (1 account with balance) instead of file import */ - key: 'init.dev-init'; - type: boolean; - } - | { - /** Address of dev-account. Leave empty to use the dev-wallet. */ - key: 'init.dev-init-address'; - type: string; - } - | { - /** Number of preinit blocks. Must exist in ancient database. */ - key: 'init.dev-init-blocknum'; - type: number; - } - | { - /** path to save temp downloaded file (default "/tmp/") */ - key: 'init.download-path'; - type: string; - } - | { - /** how long to wait between polling attempts (default 1m0s) */ - key: 'init.download-poll'; - type: string; - } - | { - /** init with empty state */ - key: 'init.empty'; - type: boolean; - } - | { - /** if true: in case database exists init code will be reexecuted and genesis block compared to database */ - key: 'init.force'; - type: boolean; - } - | { - /** path for json data to import */ - key: 'init.import-file'; - type: string; - } - | { - /** pruning for a given use: "full" for full nodes serving RPC requests, or "validator" for validators */ - key: 'init.prune'; - type: string; - } - | { - /** the amount of memory in megabytes to use for the pruning bloom filter (higher values prune better) (default 2048) */ - key: 'init.prune-bloom-size'; - type: number; - } - | { - /** block number to start recreating missing states from (0 = disabled) */ - key: 'init.recreate-missing-state-from'; - type: number; - } - | { - /** forces a reset to an old message height. Also set max-reorg-resequence-depth=0 to force re-reading messages (default -1) */ - key: 'init.reset-to-message'; - type: number; - } - | { - /** quit after init is done */ - key: 'init.then-quit'; - type: boolean; - } - | { - /** url to download initializtion data - will poll if download fails */ - key: 'init.url'; - type: string; - } - | { - /** Requested location to place the IPC endpoint. An empty path disables IPC. */ - key: 'ipc.path'; - type: string; - } - | { - /** log level (default 3) */ - key: 'log-level'; - type: number; - } - | { - /** log type (plaintext or json) (default "plaintext") */ - key: 'log-type'; - type: string; - } - | { - /** enable metrics */ - key: 'metrics'; - type: boolean; - } - | { - /** metrics server address (default "127.0.0.1") */ - key: 'metrics-server.addr'; - type: string; - } - | { - /** metrics server port (default 6070) */ - key: 'metrics-server.port'; - type: number; - } - | { - /** metrics server update interval (default 3s) */ - key: 'metrics-server.update-interval'; - type: string; - } - | { - /** batch compression level (default 11) */ - key: 'node.batch-poster.compression-level'; - type: number; - } - | { - /** In AnyTrust mode, the period which DASes are requested to retain the stored batches. (default 360h0m0s) */ - key: 'node.batch-poster.das-retention-period'; - type: string; - } - | { - /** if true, don't put transactions in the mempool that spend a total greater than the batch poster's balance (default true) */ - key: 'node.batch-poster.data-poster.allocate-mempool-balance'; - type: boolean; - } - | { - /** clear database storage */ - key: 'node.batch-poster.data-poster.dangerous.clear-dbstorage'; - type: boolean; - } - | { - /** unit to measure the time elapsed since creation of transaction used for maximum fee cap calculation (default 10m0s) */ - key: 'node.batch-poster.data-poster.elapsed-time-base'; - type: string; - } - | { - /** weight given to the units of time elapsed used for maximum fee cap calculation (default 10) */ - key: 'node.batch-poster.data-poster.elapsed-time-importance'; - type: number; - } - | { - /** external signer address */ - key: 'node.batch-poster.data-poster.external-signer.address'; - type: string; - } - | { - /** rpc client cert */ - key: 'node.batch-poster.data-poster.external-signer.client-cert'; - type: string; - } - | { - /** rpc client private key */ - key: 'node.batch-poster.data-poster.external-signer.client-private-key'; - type: string; - } - | { - /** external signer method (default "eth_signTransaction") */ - key: 'node.batch-poster.data-poster.external-signer.method'; - type: string; - } - | { - /** external signer root CA */ - key: 'node.batch-poster.data-poster.external-signer.root-ca'; - type: string; - } - | { - /** external signer url */ - key: 'node.batch-poster.data-poster.external-signer.url'; - type: string; - } - | { - /** encodes items in a legacy way (as it was before dropping generics) */ - key: 'node.batch-poster.data-poster.legacy-storage-encoding'; - type: boolean; - } - | { - /** mathematical formula to calculate maximum fee cap gwei the result of which would be float64. This expression is expected to be evaluated please refer https://github.com/Knetic/govaluate/blob/master/MANUAL.md to find all available mathematical operators. Currently available variables to construct the formula are BacklogOfBatches, UrgencyGWei, ElapsedTime, ElapsedTimeBase, ElapsedTimeImportance, and TargetPriceGWei (default "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei") */ - key: 'node.batch-poster.data-poster.max-fee-cap-formula'; - type: string; - } - | { - /** the maximum number of transactions to have queued in the mempool at once (0 = unlimited) (default 20) */ - key: 'node.batch-poster.data-poster.max-mempool-transactions'; - type: number; - } - | { - /** the maximum number of unconfirmed transactions to track at once (0 = unlimited) */ - key: 'node.batch-poster.data-poster.max-queued-transactions'; - type: number; - } - | { - /** the maximum tip cap to post transactions at (default 5) */ - key: 'node.batch-poster.data-poster.max-tip-cap-gwei'; - type: number; - } - | { - /** the minimum fee cap to post transactions at */ - key: 'node.batch-poster.data-poster.min-fee-cap-gwei'; - type: number; - } - | { - /** the minimum tip cap to post transactions at (default 0.05) */ - key: 'node.batch-poster.data-poster.min-tip-cap-gwei'; - type: number; - } - | { - /** the maximum probable reorg depth, used to determine when a transaction will no longer likely need replaced-by-fee (default 1) */ - key: 'node.batch-poster.data-poster.nonce-rbf-soft-confs'; - type: number; - } - | { - /** disable message signature verification */ - key: 'node.batch-poster.data-poster.redis-signer.dangerous.disable-signature-verification'; - type: boolean; - } - | { - /** a fallback key used for message verification */ - key: 'node.batch-poster.data-poster.redis-signer.fallback-verification-key'; - type: string; - } - | { - /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ - key: 'node.batch-poster.data-poster.redis-signer.signing-key'; - type: string; - } - | { - /** comma-separated list of durations since first posting to attempt a replace-by-fee (default "5m,10m,20m,30m,1h,2h,4h,6h,8h,12h,16h,18h,20h,22h") */ - key: 'node.batch-poster.data-poster.replacement-times'; - type: string; - } - | { - /** the target price to use for maximum fee cap calculation (default 60) */ - key: 'node.batch-poster.data-poster.target-price-gwei'; - type: number; - } - | { - /** the urgency to use for maximum fee cap calculation (default 2) */ - key: 'node.batch-poster.data-poster.urgency-gwei'; - type: number; - } - | { - /** uses database storage when enabled (default true) */ - key: 'node.batch-poster.data-poster.use-db-storage'; - type: boolean; - } - | { - /** uses noop storage, it doesn't store anything */ - key: 'node.batch-poster.data-poster.use-noop-storage'; - type: boolean; - } - | { - /** only treat a transaction as confirmed after L1 finality has been achieved (recommended) (default true) */ - key: 'node.batch-poster.data-poster.wait-for-l1-finality'; - type: boolean; - } - | { - /** If unable to batch to DAS, disable fallback storing data on chain */ - key: 'node.batch-poster.disable-das-fallback-store-data-on-chain'; - type: boolean; - } - | { - /** enable posting batches to l1 */ - key: 'node.batch-poster.enable'; - type: boolean; - } - | { - /** how long to delay after error posting batch (default 10s) */ - key: 'node.batch-poster.error-delay'; - type: string; - } - | { - /** use this much more gas than estimation says is necessary to post batches (default 50000) */ - key: 'node.batch-poster.extra-batch-gas'; - type: number; - } - | { - /** The gas refunder contract address (optional) */ - key: 'node.batch-poster.gas-refunder-address'; - type: string; - } - | { - /** if the parent chain supports 4844 blobs and ignore-blob-price is true, post 4844 blobs even if it's not price efficient */ - key: 'node.batch-poster.ignore-blob-price'; - type: boolean; - } - | { - /** only post messages to batches when they're within the max future block/timestamp as of this L1 block tag ("safe", "finalized", "latest", or "ignore" to ignore this check) */ - key: 'node.batch-poster.l1-block-bound'; - type: string; - } - | { - /** post batches even if not within the layer 1 future bounds if we're within this margin of the max delay (default 1h0m0s) */ - key: 'node.batch-poster.l1-block-bound-bypass'; - type: string; - } - | { - /** maximum 4844 blob enabled batch size (default 779288) */ - key: 'node.batch-poster.max-4844-batch-size'; - type: number; - } - | { - /** maximum batch posting delay (default 1h0m0s) */ - key: 'node.batch-poster.max-delay'; - type: string; - } - | { - /** maximum batch size (default 100000) */ - key: 'node.batch-poster.max-size'; - type: number; - } - | { - /** account to use (default is first account in keystore) */ - key: 'node.batch-poster.parent-chain-wallet.account'; - type: string; - } - | { - /** if true, creates new key then exits */ - key: 'node.batch-poster.parent-chain-wallet.only-create-key'; - type: boolean; - } - | { - /** wallet passphrase (default "PASSWORD_NOT_SET") */ - key: 'node.batch-poster.parent-chain-wallet.password'; - type: string; - } - | { - /** pathname for wallet (default "batch-poster-wallet") */ - key: 'node.batch-poster.parent-chain-wallet.pathname'; - type: string; - } - | { - /** private key for wallet */ - key: 'node.batch-poster.parent-chain-wallet.private-key'; - type: string; - } - | { - /** how long to wait after no batches are ready to be posted before checking again (default 10s) */ - key: 'node.batch-poster.poll-interval'; - type: string; - } - | { - /** if the parent chain supports 4844 blobs and they're well priced, post EIP-4844 blobs */ - key: 'node.batch-poster.post-4844-blobs'; - type: boolean; - } - | { - /** should node always try grabing lock in background */ - key: 'node.batch-poster.redis-lock.background-lock'; - type: boolean; - } - | { - /** if false, always treat this as locked and don't write the lock to redis (default true) */ - key: 'node.batch-poster.redis-lock.enable'; - type: boolean; - } - | { - /** key for lock */ - key: 'node.batch-poster.redis-lock.key'; - type: string; - } - | { - /** how long lock is held (default 1m0s) */ - key: 'node.batch-poster.redis-lock.lockout-duration'; - type: string; - } - | { - /** this node's id prefix when acquiring the lock (optional) */ - key: 'node.batch-poster.redis-lock.my-id'; - type: string; - } - | { - /** how long between consecutive calls to redis (default 10s) */ - key: 'node.batch-poster.redis-lock.refresh-duration'; - type: string; - } - | { - /** if non-empty, the Redis URL to store queued transactions in */ - key: 'node.batch-poster.redis-url'; - type: string; - } - | { - /** post batches with access lists to reduce gas usage (disabled for L3s) (default true) */ - key: 'node.batch-poster.use-access-lists'; - type: boolean; - } - | { - /** wait for the max batch delay, even if the batch is full */ - key: 'node.batch-poster.wait-for-max-delay'; - type: boolean; - } - | { - /** current wasm module root ('current' read from chain, 'latest' from machines/latest dir, or provide hash) (default "current") */ - key: 'node.block-validator.current-module-root'; - type: string; - } - | { - /** resets block-by-block validation, starting again at genesis */ - key: 'node.block-validator.dangerous.reset-block-validation'; - type: boolean; - } - | { - /** enable block-by-block validation */ - key: 'node.block-validator.enable'; - type: boolean; - } - | { - /** failing a validation is treated as a fatal error (default true) */ - key: 'node.block-validator.failure-is-fatal'; - type: boolean; - } - | { - /** prepare entries for up to that many blocks ahead of validation (small footprint) (default 1024) */ - key: 'node.block-validator.forward-blocks'; - type: number; - } - | { - /** minimum free-memory limit after reaching which the blockvalidator pauses validation. Enabled by default as 1GB, to disable provide empty string (default "default") */ - key: 'node.block-validator.memory-free-limit'; - type: string; - } - | { - /** pending upgrade wasm module root to additionally validate (hash, 'latest' or empty) (default "latest") */ - key: 'node.block-validator.pending-upgrade-module-root'; - type: string; - } - | { - /** record that many blocks ahead of validation (larger footprint) (default 24) */ - key: 'node.block-validator.prerecorded-blocks'; - type: number; - } - | { - /** poll time to check validations (default 1s) */ - key: 'node.block-validator.validation-poll'; - type: string; - } - | { - /** array of validation rpc configs given as a json string. time duration should be supplied in number indicating nanoseconds (default "default") */ - key: 'node.block-validator.validation-server-configs-list'; - type: string; - } - | { - /** limit size of arguments in log entries (default 2048) */ - key: 'node.block-validator.validation-server.arg-log-limit'; - type: number; - } - | { - /** how long to wait for initial connection */ - key: 'node.block-validator.validation-server.connection-wait'; - type: string; - } - | { - /** path to file with jwtsecret for validation - ignored if url is self or self-auth */ - key: 'node.block-validator.validation-server.jwtsecret'; - type: string; - } - | { - /** number of retries in case of failure(0 mean one attempt) (default 3) */ - key: 'node.block-validator.validation-server.retries'; - type: number; - } - | { - /** delay between retries */ - key: 'node.block-validator.validation-server.retry-delay'; - type: string; - } - | { - /** Errors matching this regular expression are automatically retried (default "websocket: close.*|dial tcp .*|.*i/o timeout|.*connection reset by peer|.*connection refused") */ - key: 'node.block-validator.validation-server.retry-errors'; - type: string; - } - | { - /** per-response timeout (0-disabled) */ - key: 'node.block-validator.validation-server.timeout'; - type: string; - } - | { - /** url of server, use self for loopback websocket, self-auth for loopback with authentication (default "self-auth") */ - key: 'node.block-validator.validation-server.url'; - type: string; - } - | { - /** DANGEROUS! disables the EIP-4844 blob reader, which is necessary to read batches */ - key: 'node.dangerous.disable-blob-reader'; - type: boolean; - } - | { - /** DANGEROUS! disables listening to L1. To be used in test nodes only */ - key: 'node.dangerous.no-l1-listener'; - type: boolean; - } - | { - /** DANGEROUS! allows sequencing without sequencer-coordinator */ - key: 'node.dangerous.no-sequencer-coordinator'; - type: boolean; - } - | { - /** enable Anytrust Data Availability mode */ - key: 'node.data-availability.enable'; - type: boolean; - } - | { - /** enable storage/retrieval of sequencer batch data from IPFS */ - key: 'node.data-availability.ipfs-storage.enable'; - type: boolean; - } - | { - /** list of IPFS peers to connect to, eg /ip4/1.2.3.4/tcp/12345/p2p/abc...xyz */ - key: 'node.data-availability.ipfs-storage.peers'; - type: string[]; - } - | { - /** pin sequencer batch data in IPFS (default true) */ - key: 'node.data-availability.ipfs-storage.pin-after-get'; - type: boolean; - } - | { - /** percent of sequencer batch data to pin, as a floating point number in the range 0.0 to 100.0 (default 100) */ - key: 'node.data-availability.ipfs-storage.pin-percentage'; - type: number; - } - | { - /** comma separated list of IPFS profiles to use, see https://docs.ipfs.tech/how-to/default-profile */ - key: 'node.data-availability.ipfs-storage.profiles'; - type: string; - } - | { - /** timeout for IPFS reads, since by default it will wait forever. Treat timeout as not found (default 1m0s) */ - key: 'node.data-availability.ipfs-storage.read-timeout'; - type: string; - } - | { - /** directory to use to store the local IPFS repo */ - key: 'node.data-availability.ipfs-storage.repo-dir'; - type: string; - } - | { - /** whether the Data Availability Service should fail immediately on errors (not recommended) */ - key: 'node.data-availability.panic-on-error'; - type: boolean; - } - | { - /** parent chain RPC connection attempts (spaced out at least 1 second per attempt, 0 to retry infinitely), only used in standalone daserver; when running as part of a node that node's parent chain configuration is used (default 15) */ - key: 'node.data-availability.parent-chain-connection-attempts'; - type: number; - } - | { - /** URL for parent chain node, only used in standalone daserver; when running as part of a node that node's L1 configuration is used */ - key: 'node.data-availability.parent-chain-node-url'; - type: string; - } - | { - /** Data Availability Service timeout duration for Store requests (default 5s) */ - key: 'node.data-availability.request-timeout'; - type: string; - } - | { - /** enable retrieval of sequencer batch data from a list of remote REST endpoints; if other DAS storage types are enabled, this mode is used as a fallback */ - key: 'node.data-availability.rest-aggregator.enable'; - type: boolean; - } - | { - /** number of stats entries (latency and success rate) to keep for each REST endpoint; controls whether strategy is faster or slower to respond to changing conditions (default 20) */ - key: 'node.data-availability.rest-aggregator.max-per-endpoint-stats'; - type: number; - } - | { - /** a URL to a list of URLs of REST das endpoints that is checked at startup; additive with the url option */ - key: 'node.data-availability.rest-aggregator.online-url-list'; - type: string; - } - | { - /** time interval to periodically fetch url list from online-url-list (default 1h0m0s) */ - key: 'node.data-availability.rest-aggregator.online-url-list-fetch-interval'; - type: string; - } - | { - /** number of consecutive GetByHash calls to the aggregator where each call will cause it to select from REST endpoints in order of best latency and success rate, before switching to explore mode (default 1000) */ - key: 'node.data-availability.rest-aggregator.simple-explore-exploit-strategy.exploit-iterations'; - type: number; - } - | { - /** number of consecutive GetByHash calls to the aggregator where each call will cause it to randomly select from REST endpoints until one returns successfully, before switching to exploit mode (default 20) */ - key: 'node.data-availability.rest-aggregator.simple-explore-exploit-strategy.explore-iterations'; - type: number; - } - | { - /** strategy to use to determine order and parallelism of calling REST endpoint URLs; valid options are 'simple-explore-exploit' (default "simple-explore-exploit") */ - key: 'node.data-availability.rest-aggregator.strategy'; - type: string; - } - | { - /** how frequently to update the strategy with endpoint latency and error rate data (default 10s) */ - key: 'node.data-availability.rest-aggregator.strategy-update-interval'; - type: string; - } - | { - /** check if the data already exists in this DAS's storage. Must be disabled for fast sync with an IPFS backend (default true) */ - key: 'node.data-availability.rest-aggregator.sync-to-storage.check-already-exists'; - type: boolean; - } - | { - /** time to wait if encountered an error before retrying (default 1s) */ - key: 'node.data-availability.rest-aggregator.sync-to-storage.delay-on-error'; - type: string; - } - | { - /** eagerly sync batch data to this DAS's storage from the rest endpoints, using L1 as the index of batch data hashes; otherwise only sync lazily */ - key: 'node.data-availability.rest-aggregator.sync-to-storage.eager'; - type: boolean; - } - | { - /** when eagerly syncing, start indexing forward from this L1 block. Only used if there is no sync state */ - key: 'node.data-availability.rest-aggregator.sync-to-storage.eager-lower-bound-block'; - type: number; - } - | { - /** log only on failures to write when syncing; otherwise treat it as an error (default true) */ - key: 'node.data-availability.rest-aggregator.sync-to-storage.ignore-write-errors'; - type: boolean; - } - | { - /** when eagerly syncing, max l1 blocks to read per poll (default 100) */ - key: 'node.data-availability.rest-aggregator.sync-to-storage.parent-chain-blocks-per-read'; - type: number; - } - | { - /** period to retain synced data (defaults to forever) (default 2562047h47m16.854775807s) */ - key: 'node.data-availability.rest-aggregator.sync-to-storage.retention-period'; - type: string; - } - | { - /** directory to store the sync state in, ie the block number currently synced up to, so that we don't sync from scratch each time */ - key: 'node.data-availability.rest-aggregator.sync-to-storage.state-dir'; - type: string; - } - | { - /** list of URLs including 'http://' or 'https://' prefixes and port numbers to REST DAS endpoints; additive with the online-url-list option */ - key: 'node.data-availability.rest-aggregator.urls'; - type: string[]; - } - | { - /** time to wait until trying the next set of REST endpoints while waiting for a response; the next set of REST endpoints is determined by the strategy selected (default 2s) */ - key: 'node.data-availability.rest-aggregator.wait-before-try-next'; - type: string; - } - | { - /** Number of assumed honest backends (H). If there are N backends, K=N+1-H valid responses are required to consider an Store request to be successful. */ - key: 'node.data-availability.rpc-aggregator.assumed-honest'; - type: number; - } - | { - /** JSON RPC backend configuration */ - key: 'node.data-availability.rpc-aggregator.backends'; - type: string; - } - | { - /** enable storage/retrieval of sequencer batch data from a list of RPC endpoints; this should only be used by the batch poster and not in combination with other DAS storage types */ - key: 'node.data-availability.rpc-aggregator.enable'; - type: boolean; - } - | { - /** parent chain address of SequencerInbox contract */ - key: 'node.data-availability.sequencer-inbox-address'; - type: string; - } - | { - /** enable delayed sequencer */ - key: 'node.delayed-sequencer.enable'; - type: boolean; - } - | { - /** how many blocks in the past L1 block is considered final (ignored when using Merge finality) (default 20) */ - key: 'node.delayed-sequencer.finalize-distance'; - type: number; - } - | { - /** whether to wait for full finality before sequencing delayed messages */ - key: 'node.delayed-sequencer.require-full-finality'; - type: boolean; - } - | { - /** whether to use The Merge's notion of finality before sequencing delayed messages (default true) */ - key: 'node.delayed-sequencer.use-merge-finality'; - type: boolean; - } - | { - /** enable per message deflate compression support (default true) */ - key: 'node.feed.input.enable-compression'; - type: boolean; - } - | { - /** initial duration to wait before reconnect (default 1s) */ - key: 'node.feed.input.reconnect-initial-backoff'; - type: string; - } - | { - /** maximum duration to wait before reconnect (default 1m4s) */ - key: 'node.feed.input.reconnect-maximum-backoff'; - type: string; - } - | { - /** require chain id to be present on connect */ - key: 'node.feed.input.require-chain-id'; - type: boolean; - } - | { - /** require feed version to be present on connect */ - key: 'node.feed.input.require-feed-version'; - type: boolean; - } - | { - /** list of secondary URLs of sequencer feed source. Would be started in the order they appear in the list when primary feeds fails */ - key: 'node.feed.input.secondary-url'; - type: string[]; - } - | { - /** duration to wait before timing out connection to sequencer feed (default 20s) */ - key: 'node.feed.input.timeout'; - type: string; - } - | { - /** list of primary URLs of sequencer feed source */ - key: 'node.feed.input.url'; - type: string[]; - } - | { - /** accept verified message from sequencer (default true) */ - key: 'node.feed.input.verify.accept-sequencer'; - type: boolean; - } - | { - /** a list of allowed addresses */ - key: 'node.feed.input.verify.allowed-addresses'; - type: string[]; - } - | { - /** accept empty as valid signature (default true) */ - key: 'node.feed.input.verify.dangerous.accept-missing'; - type: boolean; - } - | { - /** address to bind the relay feed output to */ - key: 'node.feed.output.addr'; - type: string; - } - | { - /** the maximum number of messages each segment within the backlog can contain (default 240) */ - key: 'node.feed.output.backlog.segment-limit'; - type: number; - } - | { - /** delay the first messages sent to each client by this amount */ - key: 'node.feed.output.client-delay'; - type: string; - } - | { - /** duration to wait before timing out connections to client (default 15s) */ - key: 'node.feed.output.client-timeout'; - type: string; - } - | { - /** enable broadcaster per-client connection limiting */ - key: 'node.feed.output.connection-limits.enable'; - type: boolean; - } - | { - /** limit clients, as identified by IPv4/v6 address, to this many connections to this relay (default 5) */ - key: 'node.feed.output.connection-limits.per-ip-limit'; - type: number; - } - | { - /** limit ipv6 clients, as identified by IPv6 address masked with /48, to this many connections to this relay (default 20) */ - key: 'node.feed.output.connection-limits.per-ipv6-cidr-48-limit'; - type: number; - } - | { - /** limit ipv6 clients, as identified by IPv6 address masked with /64, to this many connections to this relay (default 10) */ - key: 'node.feed.output.connection-limits.per-ipv6-cidr-64-limit'; - type: number; - } - | { - /** time to wait after a relay client disconnects before the disconnect is registered with respect to the limit for this client */ - key: 'node.feed.output.connection-limits.reconnect-cooldown-period'; - type: string; - } - | { - /** don't sign feed messages (default true) */ - key: 'node.feed.output.disable-signing'; - type: boolean; - } - | { - /** enable broadcaster */ - key: 'node.feed.output.enable'; - type: boolean; - } - | { - /** enable per message deflate compression support */ - key: 'node.feed.output.enable-compression'; - type: boolean; - } - | { - /** duration to wait before timing out HTTP to WS upgrade (default 1s) */ - key: 'node.feed.output.handshake-timeout'; - type: string; - } - | { - /** only supply catchup buffer if requested sequence number is reasonable */ - key: 'node.feed.output.limit-catchup'; - type: boolean; - } - | { - /** log every client connect */ - key: 'node.feed.output.log-connect'; - type: boolean; - } - | { - /** log every client disconnect */ - key: 'node.feed.output.log-disconnect'; - type: boolean; - } - | { - /** the maximum size of the catchup buffer (-1 means unlimited) (default -1) */ - key: 'node.feed.output.max-catchup'; - type: number; - } - | { - /** maximum number of messages allowed to accumulate before client is disconnected (default 4096) */ - key: 'node.feed.output.max-send-queue'; - type: number; - } - | { - /** duration for ping interval (default 5s) */ - key: 'node.feed.output.ping'; - type: string; - } - | { - /** port to bind the relay feed output to (default "9642") */ - key: 'node.feed.output.port'; - type: string; - } - | { - /** queue size for HTTP to WS upgrade (default 100) */ - key: 'node.feed.output.queue'; - type: number; - } - | { - /** duration to wait before timing out reading data (i.e. pings) from clients (default 1s) */ - key: 'node.feed.output.read-timeout'; - type: string; - } - | { - /** require clients to use compression */ - key: 'node.feed.output.require-compression'; - type: boolean; - } - | { - /** don't connect if client version not present */ - key: 'node.feed.output.require-version'; - type: boolean; - } - | { - /** sign broadcast messages */ - key: 'node.feed.output.signed'; - type: boolean; - } - | { - /** number of threads to reserve for HTTP to WS upgrade (default 100) */ - key: 'node.feed.output.workers'; - type: number; - } - | { - /** duration to wait before timing out writing data to clients (default 2s) */ - key: 'node.feed.output.write-timeout'; - type: string; - } - | { - /** the maximum time to wait between inbox checks (if not enough new blocks are found) (default 1m0s) */ - key: 'node.inbox-reader.check-delay'; - type: string; - } - | { - /** the default number of blocks to read at once (will vary based on traffic by default) (default 100) */ - key: 'node.inbox-reader.default-blocks-to-read'; - type: number; - } - | { - /** number of latest blocks to ignore to reduce reorgs */ - key: 'node.inbox-reader.delay-blocks'; - type: number; - } - | { - /** erase future transactions in addition to overwriting existing ones on reorg */ - key: 'node.inbox-reader.hard-reorg'; - type: boolean; - } - | { - /** if adjust-blocks-to-read is enabled, the maximum number of blocks to read at once (default 2000) */ - key: 'node.inbox-reader.max-blocks-to-read'; - type: number; - } - | { - /** the minimum number of blocks to read at once (when caught up lowers load on L1) (default 1) */ - key: 'node.inbox-reader.min-blocks-to-read'; - type: number; - } - | { - /** mode to only read latest or safe or finalized L1 blocks. Enabling safe or finalized disables feed input and output. Defaults to latest. Takes string input, valid strings- latest, safe, finalized (default "latest") */ - key: 'node.inbox-reader.read-mode'; - type: string; - } - | { - /** if adjust-blocks-to-read is enabled, the target number of messages to read at once (default 500) */ - key: 'node.inbox-reader.target-messages-read'; - type: number; - } - | { - /** should node always try grabing lock in background */ - key: 'node.maintenance.lock.background-lock'; - type: boolean; - } - | { - /** if false, always treat this as locked and don't write the lock to redis (default true) */ - key: 'node.maintenance.lock.enable'; - type: boolean; - } - | { - /** key for lock */ - key: 'node.maintenance.lock.key'; - type: string; - } - | { - /** how long lock is held (default 1m0s) */ - key: 'node.maintenance.lock.lockout-duration'; - type: string; - } - | { - /** this node's id prefix when acquiring the lock (optional) */ - key: 'node.maintenance.lock.my-id'; - type: string; - } - | { - /** how long between consecutive calls to redis (default 10s) */ - key: 'node.maintenance.lock.refresh-duration'; - type: string; - } - | { - /** UTC 24-hour time of day to run maintenance (currently only db compaction) at (e.g. 15:00) */ - key: 'node.maintenance.time-of-day'; - type: string; - } - | { - /** enable message pruning (default true) */ - key: 'node.message-pruner.enable'; - type: boolean; - } - | { - /** min number of batches not pruned (default 2) */ - key: 'node.message-pruner.min-batches-left'; - type: number; - } - | { - /** interval for running message pruner (default 1m0s) */ - key: 'node.message-pruner.prune-interval'; - type: string; - } - | { - /** Dangerous! only meant to be used by system tests */ - key: 'node.parent-chain-reader.dangerous.wait-for-tx-approval-safe-poll'; - type: string; - } - | { - /** enable reader connection (default true) */ - key: 'node.parent-chain-reader.enable'; - type: boolean; - } - | { - /** warns if the latest l1 block is at least this old (default 5m0s) */ - key: 'node.parent-chain-reader.old-header-timeout'; - type: string; - } - | { - /** interval when polling endpoint (default 15s) */ - key: 'node.parent-chain-reader.poll-interval'; - type: string; - } - | { - /** do not attempt to subscribe to header events */ - key: 'node.parent-chain-reader.poll-only'; - type: boolean; - } - | { - /** interval for subscribe error (default 5m0s) */ - key: 'node.parent-chain-reader.subscribe-err-interval'; - type: string; - } - | { - /** timeout when waiting for a transaction (default 5m0s) */ - key: 'node.parent-chain-reader.tx-timeout'; - type: string; - } - | { - /** use l1 data about finalized/safe blocks (default true) */ - key: 'node.parent-chain-reader.use-finality-data'; - type: boolean; - } - | { - /** if non-empty, launch an HTTP service binding to this address that returns status code 200 when chosen and 503 otherwise */ - key: 'node.seq-coordinator.chosen-healthcheck-addr'; - type: string; - } - | { - /** enable sequence coordinator */ - key: 'node.seq-coordinator.enable'; - type: boolean; - } - | { - /** the maximum amount of time to spend waiting for another sequencer to accept the lockout when handing it off on shutdown or db compaction (default 30s) */ - key: 'node.seq-coordinator.handoff-timeout'; - type: string; - } - | { - /** (default 1m0s) */ - key: 'node.seq-coordinator.lockout-duration'; - type: string; - } - | { - /** (default 30s) */ - key: 'node.seq-coordinator.lockout-spare'; - type: string; - } - | { - /** will only be marked as wanting the lockout if not too far behind (default 2000) */ - key: 'node.seq-coordinator.msg-per-poll'; - type: number; - } - | { - /** url for this sequencer if it is the chosen (default "") */ - key: 'node.seq-coordinator.my-url'; - type: string; - } - | { - /** the Redis URL to coordinate via */ - key: 'node.seq-coordinator.redis-url'; - type: string; - } - | { - /** the number of times to retry releasing the wants lockout and chosen one status on shutdown (default 4) */ - key: 'node.seq-coordinator.release-retries'; - type: number; - } - | { - /** (default 50ms) */ - key: 'node.seq-coordinator.retry-interval'; - type: string; - } - | { - /** if non-zero will add delay after transferring control (default 5s) */ - key: 'node.seq-coordinator.safe-shutdown-delay'; - type: string; - } - | { - /** (default 24h0m0s) */ - key: 'node.seq-coordinator.seq-num-duration'; - type: string; - } - | { - /** accept verified message from sequencer (default true) */ - key: 'node.seq-coordinator.signer.ecdsa.accept-sequencer'; - type: boolean; - } - | { - /** a list of allowed addresses */ - key: 'node.seq-coordinator.signer.ecdsa.allowed-addresses'; - type: string[]; - } - | { - /** accept empty as valid signature (default true) */ - key: 'node.seq-coordinator.signer.ecdsa.dangerous.accept-missing'; - type: boolean; - } - | { - /** if to fall back to symmetric hmac */ - key: 'node.seq-coordinator.signer.symmetric-fallback'; - type: boolean; - } - | { - /** if to sign with symmetric hmac */ - key: 'node.seq-coordinator.signer.symmetric-sign'; - type: boolean; - } - | { - /** disable message signature verification */ - key: 'node.seq-coordinator.signer.symmetric.dangerous.disable-signature-verification'; - type: boolean; - } - | { - /** a fallback key used for message verification */ - key: 'node.seq-coordinator.signer.symmetric.fallback-verification-key'; - type: string; - } - | { - /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ - key: 'node.seq-coordinator.signer.symmetric.signing-key'; - type: string; - } - | { - /** (default 250ms) */ - key: 'node.seq-coordinator.update-interval'; - type: string; - } - | { - /** enable sequencer */ - key: 'node.sequencer'; - type: boolean; - } - | { - /** confirmation blocks (default 12) */ - key: 'node.staker.confirmation-blocks'; - type: number; - } - | { - /** validator smart contract wallet public address */ - key: 'node.staker.contract-wallet-address'; - type: string; - } - | { - /** DANGEROUS! make assertions even when the wasm module root is wrong */ - key: 'node.staker.dangerous.ignore-rollup-wasm-module-root'; - type: boolean; - } - | { - /** DANGEROUS! allows running an L1 validator without a block validator */ - key: 'node.staker.dangerous.without-block-validator'; - type: boolean; - } - | { - /** if true, don't put transactions in the mempool that spend a total greater than the batch poster's balance (default true) */ - key: 'node.staker.data-poster.allocate-mempool-balance'; - type: boolean; - } - | { - /** clear database storage */ - key: 'node.staker.data-poster.dangerous.clear-dbstorage'; - type: boolean; - } - | { - /** unit to measure the time elapsed since creation of transaction used for maximum fee cap calculation (default 10m0s) */ - key: 'node.staker.data-poster.elapsed-time-base'; - type: string; - } - | { - /** weight given to the units of time elapsed used for maximum fee cap calculation (default 10) */ - key: 'node.staker.data-poster.elapsed-time-importance'; - type: number; - } - | { - /** external signer address */ - key: 'node.staker.data-poster.external-signer.address'; - type: string; - } - | { - /** rpc client cert */ - key: 'node.staker.data-poster.external-signer.client-cert'; - type: string; - } - | { - /** rpc client private key */ - key: 'node.staker.data-poster.external-signer.client-private-key'; - type: string; - } - | { - /** external signer method (default "eth_signTransaction") */ - key: 'node.staker.data-poster.external-signer.method'; - type: string; - } - | { - /** external signer root CA */ - key: 'node.staker.data-poster.external-signer.root-ca'; - type: string; - } - | { - /** external signer url */ - key: 'node.staker.data-poster.external-signer.url'; - type: string; - } - | { - /** encodes items in a legacy way (as it was before dropping generics) */ - key: 'node.staker.data-poster.legacy-storage-encoding'; - type: boolean; - } - | { - /** mathematical formula to calculate maximum fee cap gwei the result of which would be float64. This expression is expected to be evaluated please refer https://github.com/Knetic/govaluate/blob/master/MANUAL.md to find all available mathematical operators. Currently available variables to construct the formula are BacklogOfBatches, UrgencyGWei, ElapsedTime, ElapsedTimeBase, ElapsedTimeImportance, and TargetPriceGWei (default "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei") */ - key: 'node.staker.data-poster.max-fee-cap-formula'; - type: string; - } - | { - /** the maximum number of transactions to have queued in the mempool at once (0 = unlimited) (default 1) */ - key: 'node.staker.data-poster.max-mempool-transactions'; - type: number; - } - | { - /** the maximum number of unconfirmed transactions to track at once (0 = unlimited) */ - key: 'node.staker.data-poster.max-queued-transactions'; - type: number; - } - | { - /** the maximum tip cap to post transactions at (default 5) */ - key: 'node.staker.data-poster.max-tip-cap-gwei'; - type: number; - } - | { - /** the minimum fee cap to post transactions at */ - key: 'node.staker.data-poster.min-fee-cap-gwei'; - type: number; - } - | { - /** the minimum tip cap to post transactions at (default 0.05) */ - key: 'node.staker.data-poster.min-tip-cap-gwei'; - type: number; - } - | { - /** the maximum probable reorg depth, used to determine when a transaction will no longer likely need replaced-by-fee (default 1) */ - key: 'node.staker.data-poster.nonce-rbf-soft-confs'; - type: number; - } - | { - /** disable message signature verification */ - key: 'node.staker.data-poster.redis-signer.dangerous.disable-signature-verification'; - type: boolean; - } - | { - /** a fallback key used for message verification */ - key: 'node.staker.data-poster.redis-signer.fallback-verification-key'; - type: string; - } - | { - /** a 32-byte (64-character) hex string used to sign messages, or a path to a file containing it */ - key: 'node.staker.data-poster.redis-signer.signing-key'; - type: string; - } - | { - /** comma-separated list of durations since first posting to attempt a replace-by-fee (default "5m,10m,20m,30m,1h,2h,4h,6h,8h,12h,16h,18h,20h,22h") */ - key: 'node.staker.data-poster.replacement-times'; - type: string; - } - | { - /** the target price to use for maximum fee cap calculation (default 60) */ - key: 'node.staker.data-poster.target-price-gwei'; - type: number; - } - | { - /** the urgency to use for maximum fee cap calculation (default 2) */ - key: 'node.staker.data-poster.urgency-gwei'; - type: number; - } - | { - /** uses database storage when enabled (default true) */ - key: 'node.staker.data-poster.use-db-storage'; - type: boolean; - } - | { - /** uses noop storage, it doesn't store anything */ - key: 'node.staker.data-poster.use-noop-storage'; - type: boolean; - } - | { - /** only treat a transaction as confirmed after L1 finality has been achieved (recommended) (default true) */ - key: 'node.staker.data-poster.wait-for-l1-finality'; - type: boolean; - } - | { - /** disable validator challenge */ - key: 'node.staker.disable-challenge'; - type: boolean; - } - | { - /** enable validator (default true) */ - key: 'node.staker.enable'; - type: boolean; - } - | { - /** use this much more gas than estimation says is necessary to post transactions (default 50000) */ - key: 'node.staker.extra-gas'; - type: number; - } - | { - /** The gas refunder contract address (optional) */ - key: 'node.staker.gas-refunder-address'; - type: string; - } - | { - /** if configured with the makeNodes strategy, how often to create new assertions (bypassed in case of a dispute) (default 1h0m0s) */ - key: 'node.staker.make-assertion-interval'; - type: string; - } - | { - /** only create smart wallet contract and exit */ - key: 'node.staker.only-create-wallet-contract'; - type: boolean; - } - | { - /** account to use (default is first account in keystore) */ - key: 'node.staker.parent-chain-wallet.account'; - type: string; - } - | { - /** if true, creates new key then exits */ - key: 'node.staker.parent-chain-wallet.only-create-key'; - type: boolean; - } - | { - /** wallet passphrase (default "PASSWORD_NOT_SET") */ - key: 'node.staker.parent-chain-wallet.password'; - type: string; - } - | { - /** pathname for wallet (default "validator-wallet") */ - key: 'node.staker.parent-chain-wallet.pathname'; - type: string; - } - | { - /** private key for wallet */ - key: 'node.staker.parent-chain-wallet.private-key'; - type: string; - } - | { - /** high gas delay blocks */ - key: 'node.staker.posting-strategy.high-gas-delay-blocks'; - type: number; - } - | { - /** high gas threshold */ - key: 'node.staker.posting-strategy.high-gas-threshold'; - type: number; - } - | { - /** redis url for L1 validator */ - key: 'node.staker.redis-url'; - type: string; - } - | { - /** how often the L1 validator should check the status of the L1 rollup and maybe take action with its stake (default 1m0s) */ - key: 'node.staker.staker-interval'; - type: string; - } - | { - /** assume staked nodes are valid (default true) */ - key: 'node.staker.start-validation-from-staked'; - type: boolean; - } - | { - /** L1 validator strategy, either watchtower, defensive, stakeLatest, or makeNodes (default "Watchtower") */ - key: 'node.staker.strategy'; - type: string; - } - | { - /** use a smart contract wallet instead of an EOA address */ - key: 'node.staker.use-smart-contract-wallet'; - type: boolean; - } - | { - /** allowed lag between messages read and blocks built (default 20) */ - key: 'node.sync-monitor.block-build-lag'; - type: number; - } - | { - /** allowed lag between messages read from sequencer inbox and blocks built */ - key: 'node.sync-monitor.block-build-sequencer-inbox-lag'; - type: number; - } - | { - /** allowed lag between local and remote messages (default 15) */ - key: 'node.sync-monitor.coordinator-msg-lag'; - type: number; - } - | { - /** wait for block validator to complete before returning finalized block number */ - key: 'node.sync-monitor.finalized-block-wait-for-block-validator'; - type: boolean; - } - | { - /** wait for block validator to complete before returning safe block number */ - key: 'node.sync-monitor.safe-block-wait-for-block-validator'; - type: boolean; - } - | { - /** delay when polling calls to execute messages (default 100ms) */ - key: 'node.transaction-streamer.execute-message-loop-delay'; - type: string; - } - | { - /** maximum cache of pending broadcaster messages (default 50000) */ - key: 'node.transaction-streamer.max-broadcaster-queue-size'; - type: number; - } - | { - /** maximum number of messages to attempt to resequence on reorg (0 = never resequence, -1 = always resequence) (default 1024) */ - key: 'node.transaction-streamer.max-reorg-resequence-depth'; - type: number; - } - | { - /** P2P bootnodes */ - key: 'p2p.bootnodes'; - type: string[]; - } - | { - /** P2P bootnodes v5 */ - key: 'p2p.bootnodes-v5'; - type: string[]; - } - | { - /** P2P discovery v4 */ - key: 'p2p.discovery-v4'; - type: boolean; - } - | { - /** P2P discovery v5 */ - key: 'p2p.discovery-v5'; - type: boolean; - } - | { - /** P2P listen address */ - key: 'p2p.listen-addr'; - type: string; - } - | { - /** P2P max peers (default 50) */ - key: 'p2p.max-peers'; - type: number; - } - | { - /** P2P no dial (default true) */ - key: 'p2p.no-dial'; - type: boolean; - } - | { - /** P2P no discovery (default true) */ - key: 'p2p.no-discovery'; - type: boolean; - } - | { - /** Beacon Chain RPC URL to use for fetching blobs (normally on port 3500) */ - key: 'parent-chain.blob-client.beacon-url'; - type: string; - } - | { - /** Full path of the directory to save fetched blobs */ - key: 'parent-chain.blob-client.blob-directory'; - type: string; - } - | { - /** limit size of arguments in log entries (default 2048) */ - key: 'parent-chain.connection.arg-log-limit'; - type: number; - } - | { - /** how long to wait for initial connection (default 1m0s) */ - key: 'parent-chain.connection.connection-wait'; - type: string; - } - | { - /** path to file with jwtsecret for validation - ignored if url is self or self-auth */ - key: 'parent-chain.connection.jwtsecret'; - type: string; - } - | { - /** number of retries in case of failure(0 mean one attempt) (default 2) */ - key: 'parent-chain.connection.retries'; - type: number; - } - | { - /** delay between retries */ - key: 'parent-chain.connection.retry-delay'; - type: string; - } - | { - /** Errors matching this regular expression are automatically retried */ - key: 'parent-chain.connection.retry-errors'; - type: string; - } - | { - /** per-response timeout (0-disabled) (default 1m0s) */ - key: 'parent-chain.connection.timeout'; - type: string; - } - | { - /** url of server, use self for loopback websocket, self-auth for loopback with authentication */ - key: 'parent-chain.connection.url'; - type: string; - } - | { - /** if set other than 0, will be used to validate database and L1 connection */ - key: 'parent-chain.id'; - type: number; - } - | { - /** account to use (default is first account in keystore) */ - key: 'parent-chain.wallet.account'; - type: string; - } - | { - /** if true, creates new key then exits */ - key: 'parent-chain.wallet.only-create-key'; - type: boolean; - } - | { - /** wallet passphrase (default "PASSWORD_NOT_SET") */ - key: 'parent-chain.wallet.password'; - type: string; - } - | { - /** pathname for wallet (default "wallet") */ - key: 'parent-chain.wallet.pathname'; - type: string; - } - | { - /** private key for wallet */ - key: 'parent-chain.wallet.private-key'; - type: string; - } - | { - /** directory of ancient where the chain freezer can be opened */ - key: 'persistent.ancient'; - type: string; - } - | { - /** directory to store chain state */ - key: 'persistent.chain'; - type: string; - } - | { - /** backing database implementation to use ('leveldb' or 'pebble') (default "leveldb") */ - key: 'persistent.db-engine'; - type: string; - } - | { - /** directory to store global config (default ".arbitrum") */ - key: 'persistent.global-config'; - type: string; - } - | { - /** number of file descriptor handles to use for the database (default 512) */ - key: 'persistent.handles'; - type: number; - } - | { - /** directory to store log file */ - key: 'persistent.log-dir'; - type: string; - } - | { - /** enable pprof */ - key: 'pprof'; - type: boolean; - } - | { - /** pprof server address (default "127.0.0.1") */ - key: 'pprof-cfg.addr'; - type: string; - } - | { - /** pprof server port (default 6071) */ - key: 'pprof-cfg.port'; - type: number; - } - | { - /** the maximum number of requests in a batch (0 means no limit) (default 1000) */ - key: 'rpc.batch-request-limit'; - type: number; - } - | { - /** the maximum response size for a JSON-RPC request measured in bytes (0 means no limit) (default 10000000) */ - key: 'rpc.max-batch-response-size'; - type: number; - } - | { - /** validate is an authenticated API (default true) */ - key: 'validation.api-auth'; - type: boolean; - } - | { - /** validate is a public API */ - key: 'validation.api-public'; - type: boolean; - } - | { - /** timeout before discarding execution run (default 15m0s) */ - key: 'validation.arbitrator.execution-run-timeout'; - type: string; - } - | { - /** how many machines to store in cache while working on a challenge (should be even) (default 4) */ - key: 'validation.arbitrator.execution.cached-challenge-machines'; - type: number; - } - | { - /** initial steps between machines (default 100000) */ - key: 'validation.arbitrator.execution.initial-steps'; - type: number; - } - | { - /** path to write machines to (default "./target/output") */ - key: 'validation.arbitrator.output-path'; - type: string; - } - | { - /** number of concurrent validation threads */ - key: 'validation.arbitrator.workers'; - type: number; - } - | { - /** use Cranelift instead of LLVM when validating blocks using the jit-accelerated block validator (default true) */ - key: 'validation.jit.cranelift'; - type: boolean; - } - | { - /** if memory used by a jit wasm exceeds this limit, a warning is logged (default 4294967296) */ - key: 'validation.jit.wasm-memory-usage-limit'; - type: number; - } - | { - /** number of concurrent validation threads */ - key: 'validation.jit.workers'; - type: number; - } - | { - /** use jit for validation (default true) */ - key: 'validation.use-jit'; - type: boolean; - } - | { - /** list of WASM module roots to check if the on-chain WASM module root belongs to on node startup */ - key: 'validation.wasm.allowed-wasm-module-roots'; - type: string[]; - } - | { - /** enable check for compatibility of on-chain WASM module root with node (default true) */ - key: 'validation.wasm.enable-wasmroots-check'; - type: boolean; - } - | { - /** path to machine folders, each containing wasm files (machine.wavm.br, replay.wasm) */ - key: 'validation.wasm.root-path'; - type: string; - } - | { - /** WS-RPC server listening interface */ - key: 'ws.addr'; - type: string; - } - | { - /** APIs offered over the WS-RPC interface (default [net,web3,eth,arb]) */ - key: 'ws.api'; - type: string[]; - } - | { - /** expose private api via websocket */ - key: 'ws.expose-all'; - type: boolean; - } - | { - /** Origins from which to accept websockets requests */ - key: 'ws.origins'; - type: string[]; - } - | { - /** WS-RPC server listening port (default 8548) */ - key: 'ws.port'; - type: number; - } - | { - /** WS path path prefix on which JSON-RPC is served. Use '/' to serve on all paths */ - key: 'ws.rpcprefix'; - type: string; - }; From 34d6b035320d8521369904f5c795bb08f4640ff9 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Thu, 6 Jun 2024 11:24:33 +0200 Subject: [PATCH 23/24] clean up --- src/nodeConfigBuilderUtils.ts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/nodeConfigBuilderUtils.ts b/src/nodeConfigBuilderUtils.ts index 3cb6ee33..e1d6da34 100644 --- a/src/nodeConfigBuilderUtils.ts +++ b/src/nodeConfigBuilderUtils.ts @@ -8,7 +8,8 @@ import { arbitrumSepolia, nitroTestnodeL1, nitroTestnodeL2, - nitroTestnodeL3, + base, + baseSepolia, } from './chains'; export function parentChainIsArbitrum(parentChainId: ParentChainId): boolean { @@ -17,6 +18,8 @@ export function parentChainIsArbitrum(parentChainId: ParentChainId): boolean { case mainnet.id: case sepolia.id: case holesky.id: + case base.id: + case baseSepolia.id: case nitroTestnodeL1.id: return false; @@ -24,7 +27,6 @@ export function parentChainIsArbitrum(parentChainId: ParentChainId): boolean { case arbitrumNova.id: case arbitrumSepolia.id: case nitroTestnodeL2.id: - case nitroTestnodeL3.id: return true; } } From 5c351e0f0e3bd5a6bf89306d103f88e2d23b0940 Mon Sep 17 00:00:00 2001 From: spsjvc Date: Thu, 6 Jun 2024 12:25:22 +0200 Subject: [PATCH 24/24] reuse --- src/nodeConfigBuilder.ts | 3 ++- src/nodeConfigBuilderUtils.ts | 33 --------------------------------- 2 files changed, 2 insertions(+), 34 deletions(-) diff --git a/src/nodeConfigBuilder.ts b/src/nodeConfigBuilder.ts index a54fc3ea..e9b35a42 100644 --- a/src/nodeConfigBuilder.ts +++ b/src/nodeConfigBuilder.ts @@ -2,7 +2,8 @@ import _set from 'lodash.set'; import { NodeConfig, NodeConfigOption } from './types/NodeConfig.generated'; import { CoreContracts } from './types/CoreContracts'; -import { parentChainIsArbitrum, stringifyJson } from './nodeConfigBuilderUtils'; +import { stringifyJson } from './nodeConfigBuilderUtils'; +import { parentChainIsArbitrum } from './parentChainIsArbitrum'; import { nodeConfigBuilderDefaults } from './nodeConfigBuilderDefaults'; import { ParentChainId } from './types/ParentChain'; import { ChainConfig } from './types/ChainConfig'; diff --git a/src/nodeConfigBuilderUtils.ts b/src/nodeConfigBuilderUtils.ts index e1d6da34..3d38e8d0 100644 --- a/src/nodeConfigBuilderUtils.ts +++ b/src/nodeConfigBuilderUtils.ts @@ -1,36 +1,3 @@ -import { ParentChainId } from './types/ParentChain'; -import { - mainnet, - arbitrumOne, - arbitrumNova, - sepolia, - holesky, - arbitrumSepolia, - nitroTestnodeL1, - nitroTestnodeL2, - base, - baseSepolia, -} from './chains'; - -export function parentChainIsArbitrum(parentChainId: ParentChainId): boolean { - // doing switch here to make sure it's exhaustive when checking against `ParentChainId` - switch (parentChainId) { - case mainnet.id: - case sepolia.id: - case holesky.id: - case base.id: - case baseSepolia.id: - case nitroTestnodeL1.id: - return false; - - case arbitrumOne.id: - case arbitrumNova.id: - case arbitrumSepolia.id: - case nitroTestnodeL2.id: - return true; - } -} - export function stringifyJson(json: TJson): string { return JSON.stringify(json); }