NodeConfig.generated.ts

// ---
//
// THIS FILE IS AUTOMATICALLY GENERATED AND SHOULD NOT BE EDITED MANUALLY
//
// IMAGE: offchainlabs/nitro-node:v3.6.0-fc07dd2
// TIMESTAMP: 2025-04-30T12:27:36.604Z
//
// ---
/** Nitro node configuration options */
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'?: {
    /** json encoded list of block ranges in the form of start and end block numbers in a list of size 2 (default "[[0,0]]") */
    'blocks'?: string;
    /** enables re-execution of a range of blocks against historic state */
    'enable'?: boolean;
    /** minimum number of blocks to execute per thread. When mode is random this acts as the size of random block range sample */
    'min-blocks-per-thread'?: 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 16) */
    'room'?: number;
    /** memory allowance (MB) to use for caching trie nodes in memory */
    'trie-clean-limit'?: 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[];
    /** 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;
  };
  /** before starting the node, wait until the transaction that deployed rollup is finalized (default true) */
  'ensure-rollup-deployment'?: boolean;
  'execution'?: {
    /** maximum number of blocks allowed to be queried for blockMetadata per arb_getRawBlockMetadata query. Enabled by default, set 0 to disable the limit (default 100) */
    'block-metadata-api-blocks-limit'?: number;
    /** size (in bytes) of lru cache storing the blockMetadata to service arb_getRawBlockMetadata (default 104857600) */
    'block-metadata-api-cache-size'?: number;
    '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;
      /** disable metrics collection for the stylus cache */
      'disable-stylus-cache-metrics-collection'?: boolean;
      /** 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;
      /** number of recent blocks to retain state history for (path state-scheme only) (default 345600) */
      'state-history'?: number;
      /** scheme to use for state trie storage (hash, path) (default "hash") */
      'state-scheme'?: string;
      /** capacity, in megabytes, of the LRU cache that keeps initialized stylus programs (default 256) */
      'stylus-lru-cache-capacity'?: number;
      /** amount of memory in megabytes to be used in the TrieDB Cap operation during maintenance (default 100) */
      'trie-cap-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;
      /** if greater then 0, the block processing time period of each trie write to hard-disk is shortened by a random value from range [0, trie-time-limit-random-offset) */
      'trie-time-limit-random-offset'?: string;
    };
    /** 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;
      /** timeout when polling endpoint (default 5s) */
      'poll-timeout'?: string;
      /** 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'?: {
      /** max references to store in the recording database (default 1000) */
      'max-prepared'?: number;
      /** 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'?: {
      'dangerous'?: {
        /** DANGEROUS! disables nitro checks on sequencer MaxTxDataSize against the sequencer inbox MaxDataSize */
        'disable-seq-inbox-max-data-size-check'?: boolean;
      };
      /** act and post to l1 as sequencer */
      'enable'?: boolean;
      /** enable CPU profiling and tracing */
      'enable-profiling'?: boolean;
      /** if expected surplus is lower than this value, new incoming transactions will be denied (default "default") */
      'expected-surplus-hard-threshold'?: string;
      /** if expected surplus is lower than this value, warnings are posted (default "default") */
      'expected-surplus-soft-threshold'?: string;
      '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) */
      '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[];
      'timeboost'?: {
        /** Address of the proxy pointing to the ExpressLaneAuction contract */
        'auction-contract-address'?: string;
        /** Address of the Timeboost Autonomous Auctioneer */
        'auctioneer-address'?: string;
        /** period of time before the next round where submissions for the next round will be queued (default 2s) */
        'early-submission-grace'?: string;
        /** enable timeboost based on express lane auctions */
        'enable'?: boolean;
        /** specify the express lane advantage (default 200ms) */
        'express-lane-advantage'?: string;
        /** maximum allowed difference (in terms of sequence numbers) between a future express lane tx and the current sequence count of a round (default 1000) */
        'max-future-sequence-distance'?: number;
        /** maximum amount of time (measured in blocks) that Express Lane transactions can wait in the sequencer's queue (default 5) */
        'queue-timeout-in-blocks'?: number;
        /** size of update events' buffered channels in timeboost redis coordinator (default 500) */
        'redis-update-events-channel-size'?: number;
        /** the Redis URL for expressLaneService to coordinate via (default "unset") */
        'redis-url'?: string;
        /** this sequencer's http endpoint (default "http://localhost:8547") */
        'sequencer-http-endpoint'?: string;
      };
    };
    'stylus-target'?: {
      /** stylus programs compilation target for amd64 linux (default "x86_64-linux-unknown+sse4.2+lzcnt+bmi") */
      'amd64'?: string;
      /** stylus programs compilation target for arm64 linux (default "arm64-linux-unknown+neon") */
      'arm64'?: string;
      /** Comma separated list of extra architectures to cross-compile stylus program to and cache in wasm store (additionally to local target). Currently must include at least wavm. (supported targets: wavm, arm64, amd64, host) (default [wavm]) */
      'extra-archs'?: string[];
      /** stylus programs compilation target for system other than 64-bit ARM or 64-bit x86 */
      'host'?: string;
    };
    'sync-monitor'?: {
      /** 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;
    };
    /** 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 <required-state-age> 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 (default 20) */
      '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;
    /** Max code size for dev accounts */
    'dev-max-code-size'?: 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 genesis json file */
    'genesis-json-file'?: string;
    /** path for json data to import */
    'import-file'?: string;
    /** if set, import the wasm directory when downloading a database (contains executable code - only use with highly trusted source) */
    'import-wasm'?: boolean;
    /** if set, searches for the latest snapshot of the given kind (accepted values: "archive" | "pruned" | "genesis") */
    'latest'?: string;
    /** base url used when searching for the latest (default "https://snapshot.arbitrum.foundation/") */
    'latest-base'?: 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;
    /** if true: use parallel pruning per account */
    'prune-parallel-storage-traversal'?: boolean;
    /** the number of threads to use when pruning (default 16) */
    'prune-threads'?: number;
    /** amount of memory in megabytes to cache unchanged state trie nodes with when traversing state database during pruning (default 600) */
    'prune-trie-clean-cache'?: number;
    /** rebuild local wasm database on boot if needed (otherwise-will be done lazily). Three modes are supported */
    'rebuild-local-wasm'?: string;
    /** block number to start recreating missing states from (0 = disabled) */
    'recreate-missing-state-from'?: number;
    /** rolls back the blockchain to a specified batch number (default -1) */
    'reorg-to-batch'?: number;
    /** rolls back the blockchain to the first batch at or before a given block number (default -1) */
    'reorg-to-block-batch'?: number;
    /** rolls back the blockchain to the first batch at or before a given message index (default -1) */
    'reorg-to-message-batch'?: number;
    /** quit after init is done */
    'then-quit'?: boolean;
    /** url to download initialization data - will poll if download fails */
    'url'?: string;
    /** if true: validate the checksum after downloading the snapshot (default true) */
    'validate-checksum'?: boolean;
  };
  'ipc'?: {
    /** Requested location to place the IPC endpoint. An empty path disables IPC. */
    path?: string;
  };
  /** log level, valid values are CRIT, ERROR, WARN, INFO, DEBUG, TRACE (default "INFO") */
  'log-level'?: string;
  /** 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'?: {
      /** setting this to true will run the batch against an inbox multiplexer and verifies that it produces the correct set of messages (default true) */
      'check-batch-correctness'?: boolean;
      /** batch compression level (default 11) */
      'compression-level'?: number;
      'dangerous'?: {
        /** allow posting the first batch even if sequence number doesn't match chain (useful after force-inclusion) */
        'allow-posting-first-batch-when-sequencer-message-count-mismatch'?: boolean;
        /** use this gas limit for batch posting instead of estimating it */
        'fixed-gas-limit'?: 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;
        /** comma-separated list of durations since first posting a blob transaction to attempt a replace-by-fee (default [5m0s,10m0s,30m0s,1h0m0s,4h0m0s,8h0m0s,16h0m0s,22h0m0s]) */
        'blob-tx-replacement-times'?: string[];
        'dangerous'?: {
          /** clear database storage */
          'clear-dbstorage'?: boolean;
        };
        /** disable posting new transactions, data poster will still keep confirming existing batches */
        'disable-new-tx'?: 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;
          /** skip TLS certificate verification */
          'insecure-skip-verify'?: boolean;
          /** 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;
        /** the maximum tip cap to post EIP-4844 blob carrying transactions at (default 1) */
        'max-blob-tx-tip-cap-gwei'?: 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) */
        'max-fee-bid-multiple-bips'?: 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") */
        'max-fee-cap-formula'?: string;
        /** the maximum number of transactions to have queued in the mempool at once (0 = unlimited) (default 18) */
        'max-mempool-transactions'?: number;
        /** the maximum number of weight (weight = min(1, tx.blobs)) to have queued in the mempool at once (0 = unlimited) (default 18) */
        'max-mempool-weight'?: 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 1.2) */
        'max-tip-cap-gwei'?: number;
        /** the minimum tip cap to post EIP-4844 blob carrying transactions at (default 1) */
        'min-blob-tx-tip-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;
        /** if the parent chain supports 4844 blobs and they're well priced, post EIP-4844 blobs */
        'post-4844-blobs'?: boolean;
        '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 [5m0s,10m0s,20m0s,30m0s,1h0m0s,2h0m0s,4h0m0s,6h0m0s,8h0m0s,12h0m0s,16h0m0s,18h0m0s,20h0m0s,22h0m0s]) */
        '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;
      };
      /** always treat delay buffer as updatable (default true) */
      'delay-buffer-always-updatable'?: boolean;
      /** the number of blocks to post the batch before reaching the delay buffer threshold (default 25) */
      'delay-buffer-threshold-margin'?: number;
      /** If unable to batch to DA provider, disable fallback storing data on chain */
      'disable-dap-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;
      /** for gas estimation, use this multiple of the basefee (measured in basis points) as the max fee per gas (default 15000) */
      'gas-estimate-base-fee-multiple-bips'?: 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 estimated compressed 4844 blob enabled batch size */
      'max-4844-batch-size'?: number;
      /** maximum batch posting delay (default 1h0m0s) */
      'max-delay'?: string;
      /** maximum empty batch posting delay, batch poster will only be able to post an empty batch if this time period building a batch has passed (default 72h0m0s) */
      'max-empty-batch-delay'?: string;
      /** maximum estimated compressed batch size (default 100000) */
      'max-size'?: number;
      /** if parent chain uses EIP7623 ("yes", "no", "auto") (default "auto") */
      'parent-chain-eip7623'?: string;
      '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;
      /** do not post batch if its within this duration from layer 1 minimum bounds. Requires l1-block-bound option not be set to "ignore" (default 10m0s) */
      'reorg-resistance-margin'?: 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-metadata-fetcher'?: {
      /** maximum number of blocks per arb_getRawBlockMetadata query (default 100) */
      'api-blocks-limit'?: number;
      /** enable syncing blockMetadata using a bulk blockMetadata api */
      'enable'?: boolean;
      /** maximum time between blockMetadata requests (default 32m0s) */
      'max-sync-interval'?: string;
      'source'?: {
        /** 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;
        /** websocket message size limit used by the RPC client. 0 means no limit (default 268435456) */
        'websocket-message-size-limit'?: number;
      };
      /** minimum time between blockMetadata requests (default 1m0s) */
      'sync-interval'?: string;
    };
    'block-validator'?: {
      /** limit number of old batches to keep in block-validator (default 20) */
      'batch-cache-limit'?: number;
      /** directory to write block validation inputs files (default "./target/validation_inputs") */
      'block-inputs-file-path'?: string;
      /** 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 (stores batch-copy per block) (default 128) */
      '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 32) */
      'prerecorded-blocks'?: number;
      /** limit on block recordings sent per iteration (default 20) */
      'recording-iter-limit'?: number;
      'redis-validation-client-config'?: {
        /** create redis streams if it does not exist (default true) */
        'create-streams'?: boolean;
        /** validation client name (default "redis validation client") */
        'name'?: string;
        'producer-config'?: {
          /** interval in which producer checks pending messages whether consumer processing them is inactive (default 5s) */
          'check-result-interval'?: string;
          /** timeout after which the message in redis stream is considered as errored, this prevents workers from working on wrong requests indefinitely (default 3h0m0s) */
          'request-timeout'?: string;
        };
        /** redis url */
        'redis-url'?: string;
        /** validation client room (default 2) */
        'room'?: number;
        /** prefix for stream name */
        'stream-prefix'?: string;
        /** archs required for stylus workers (default [wavm]) */
        'stylus-archs'?: string[];
      };
      /** poll time to check validations (default 1s) */
      'validation-poll'?: string;
      /** array of execution 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;
        /** websocket message size limit used by the RPC client. 0 means no limit (default 268435456) */
        'websocket-message-size-limit'?: number;
      };
    };
    'bold'?: {
      /** enable api */
      'api'?: boolean;
      /** bold api db path (default "bold-api-db") */
      'api-db-path'?: string;
      /** bold api host (default "127.0.0.1") */
      'api-host'?: string;
      /** bold api port (default 9393) */
      'api-port'?: number;
      /** confirm assertion interval (default 1m0s) */
      'assertion-confirming-interval'?: string;
      /** assertion posting interval (default 15m0s) */
      'assertion-posting-interval'?: string;
      /** scan assertion interval (default 1m0s) */
      'assertion-scanning-interval'?: string;
      /** auto-deposit stake token whenever making a move in BoLD that does not have enough stake token balance (default true) */
      'auto-deposit'?: boolean;
      /** auto-increase spending allowance of the stake token by the rollup and challenge manager contracts (default true) */
      'auto-increase-allowance'?: boolean;
      /** how often to check if staker can switch to bold (default 1m0s) */
      'check-staker-switch-interval'?: string;
      'delegated-staking'?: {
        /** enable a custom withdrawal address for staking on the rollup contract, useful for delegated stakers */
        'custom-withdrawal-address'?: string;
        /** enable delegated staking by having the validator call newStake on startup */
        'enable'?: boolean;
      };
      /** enable fast confirmation */
      'enable-fast-confirmation'?: boolean;
      /** maximum size for chunk of blocks when using get logs rpc (default 5000) */
      'max-get-log-blocks'?: number;
      /** minimum duration to wait since the parent assertion was created to post a new assertion (default 1m0s) */
      'minimum-gap-to-parent-assertion'?: string;
      /** the average block time of the parent chain where assertions are posted (default 12s) */
      'parent-chain-block-time'?: string;
      /** define the block number to use for reading data onchain, either latest, safe, or finalized (default "finalized") */
      'rpc-block-number'?: string;
      /** assume staked nodes are valid (default true) */
      'start-validation-from-staked'?: boolean;
      'state-provider-config'?: {
        /** check batch finality (default true) */
        'check-batch-finality'?: boolean;
        /** path to machine cache (default "machine-hashes-cache") */
        'machine-leaves-cache-path'?: string;
        /** name identifier for cosmetic purposes (default "default-validator") */
        'validator-name'?: string;
      };
      /** define the bold validator staker strategy, either watchtower, defensive, stakeLatest, or makeNodes (default "Watchtower") */
      'strategy'?: string;
      /** only track challenges/edges with these parent assertion hashes */
      'track-challenge-parent-assertion-hashes'?: string[];
    };
    'consensus-execution-syncer'?: {
      /** Interval in which finality data is pushed from consensus to execution (default 1s) */
      'sync-interval'?: 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;
      /** 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'?: {
          /** 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 request storage to retain synced data (default 360h0m0s) */
          '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;
          /** sync even data that is expired; needed for mirror configuration (default true) */
          'sync-expired-data'?: boolean;
        };
        /** 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. This can be specified on the command line as a JSON array, eg: [{"url": "...", "pubkey": "..."},...], or as a JSON array in the config file. (default null) */
        'backends'?: string;
        /** enable storage 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;
        /** enable data to be sent to DAS in chunks instead of all at once (default true) */
        'enable-chunked-store'?: boolean;
        /** maximum HTTP POST body size to use for individual batch chunks, including JSON RPC overhead and an estimated overhead of 512B of headers (default 524288) */
        'max-store-chunk-body-size'?: number;
      };
      /** 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;
      /** frequency to rescan for new delayed messages (the parent chain reader's poll-interval config is more important than this) (default 1s) */
      'rescan-interval'?: string;
      /** 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;
      /** 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 at (e.g. 15:00) */
      'time-of-day'?: string;
      /** maintenance is triggerable via rpc */
      'triggerable'?: boolean;
    };
    'message-pruner'?: {
      /** enable message pruning (default true) */
      'enable'?: boolean;
      /** min number of batches not pruned (default 1000) */
      '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;
      /** timeout when polling endpoint (default 5s) */
      'poll-timeout'?: string;
      /** 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'?: {
      /** (default 240h0m0s) */
      'block-metadata-duration'?: string;
      /** 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 deleting of finalized messages from redis (default true) */
      'delete-finalized-msgs'?: boolean;
      /** 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 "<?INVALID-URL?>") */
      'my-url'?: string;
      /** switch to the new Redis URL to coordinate via */
      'new-redis-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 240h0m0s) */
      '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;
        /** comma-separated list of durations since first posting a blob transaction to attempt a replace-by-fee (default [5m0s,10m0s,30m0s,1h0m0s,4h0m0s,8h0m0s,16h0m0s,22h0m0s]) */
        'blob-tx-replacement-times'?: string[];
        'dangerous'?: {
          /** clear database storage */
          'clear-dbstorage'?: boolean;
        };
        /** disable posting new transactions, data poster will still keep confirming existing batches */
        'disable-new-tx'?: 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;
          /** skip TLS certificate verification */
          'insecure-skip-verify'?: boolean;
          /** 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;
        /** the maximum tip cap to post EIP-4844 blob carrying transactions at (default 1) */
        'max-blob-tx-tip-cap-gwei'?: 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) */
        'max-fee-bid-multiple-bips'?: 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") */
        '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 weight (weight = min(1, tx.blobs)) to have queued in the mempool at once (0 = unlimited) (default 1) */
        'max-mempool-weight'?: 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 1.2) */
        'max-tip-cap-gwei'?: number;
        /** the minimum tip cap to post EIP-4844 blob carrying transactions at (default 1) */
        'min-blob-tx-tip-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;
        /** if the parent chain supports 4844 blobs and they're well priced, post EIP-4844 blobs */
        'post-4844-blobs'?: boolean;
        '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 [5m0s,10m0s,20m0s,30m0s,1h0m0s,2h0m0s,4h0m0s,6h0m0s,8h0m0s,12h0m0s,16h0m0s,18h0m0s,20h0m0s,22h0m0s]) */
        '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;
      /** enable fast confirmation */
      'enable-fast-confirmation'?: 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;
      /** range ro query from eth_getLogs */
      'log-query-batch-size'?: number;
      /** 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 msg lag while still considered in sync (default 1s) */
      'msg-lag'?: string;
    };
    '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;
      /** node will not sync past this block */
      'sync-till-block'?: number;
      /** block number to start saving blockmetadata, 0 to disable */
      'track-block-metadata-from'?: number;
    };
  };
  'parent-chain'?: {
    'blob-client'?: {
      /** Value to send with the HTTP Authorization: header for Beacon REST requests, must include both scheme and scheme parameters */
      'authorization'?: string;
      /** 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;
      /** Backup beacon Chain RPC URL to use for fetching blobs (normally on port 3500) when unable to fetch from primary */
      'secondary-beacon-url'?: 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;
      /** websocket message size limit used by the RPC client. 0 means no limit (default 268435456) */
      'websocket-message-size-limit'?: number;
    };
    /** if set other than 0, will be used to validate database and L1 connection */
    'id'?: number;
  };
  '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. If set to empty string the database type will be autodetected and if no pre-existing database is found it will default to creating new pebble database ('leveldb', 'pebble' or '' = auto-detect) */
    '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;
    'pebble'?: {
      'experimental'?: {
        /** target uncompressed size in bytes of each table block (default 4096) */
        'block-size'?: number;
        /** number of bytes to write to a SSTable before calling Sync on it in the background (default 524288) */
        'bytes-per-sync'?: number;
        /** controls the threshold of compaction debt at which additional compaction concurrency slots are added. For every multiple of this value in compaction debt bytes, an additional concurrent compaction is added. This works "on top" of l0-compaction-concurrency, so the higher of the count of compaction concurrency slots as determined by the two options is chosen. (default 1073741824) */
        'compaction-debt-concurrency'?: number;
        /** disables automatic compactions */
        'disable-automatic-compactions'?: boolean;
        /** force parallelism in the sstable Writer for the metamorphic tests. Even with the MaxWriterConcurrency option set, pebble only enables parallelism in the sstable Writer if there is enough CPU available, and this option bypasses that. */
        'force-writer-parallelism'?: boolean;
        /** target uncompressed size in bytes of each index block. When the index block size is larger than this target, two-level indexes are automatically enabled. Setting this option to a large value (such as 2147483647) disables the automatic creation of two-level indexes. (default 4096) */
        'index-block-size'?: number;
        /** The maximum number of bytes for LBase. The base level is the level which L0 is compacted into. The base level is determined dynamically based on the existing data in the LSM. The maximum number of bytes for other levels is computed dynamically based on the base level's maximum size. When the maximum number of bytes for a level is exceeded, compaction is requested. (default 67108864) */
        'l-base-max-bytes'?: number;
        /** threshold of L0 read-amplification at which compaction concurrency is enabled (if compaction-debt-concurrency was not already exceeded). Every multiple of this value enables another concurrent compaction up to max-concurrent-compactions. (default 10) */
        'l0-compaction-concurrency'?: number;
        /** count of L0 files necessary to trigger an L0 compaction (default 500) */
        'l0-compaction-file-threshold'?: number;
        /** amount of L0 read-amplification necessary to trigger an L0 compaction (default 4) */
        'l0-compaction-threshold'?: number;
        /** hard limit on L0 read-amplification, computed as the number of L0 sublevels. Writes are stopped when this threshold is reached (default 12) */
        'l0-stop-writes-threshold'?: number;
        /** maximum number of compression workers the compression queue is allowed to use. If max-writer-concurrency > 0, then the Writer will use parallelism, to compress and write blocks to disk. Otherwise, the writer will compress and write blocks to disk synchronously. */
        'max-writer-concurrency'?: number;
        /** hard limit on the number of queued of MemTables (default 2) */
        'mem-table-stop-writes-threshold'?: number;
        /** controls the frequency of read triggered compactions by adjusting AllowedSeeks in manifest.FileMetadata: AllowedSeeks = FileSize / ReadCompactionRate (default 16000) */
        'read-compaction-rate'?: number;
        /** a multiplier for the readSamplingPeriod in iterator.maybeSampleRead() to control the frequency of read sampling to trigger a read triggered compaction. A value of -1 prevents sampling and disables read triggered compactions. Geth default is -1. The pebble default is 1 << 4. which gets multiplied with a constant of 1 << 16 to yield 1 << 20 (1MB). (default -1) */
        'read-sampling-multiplier'?: number;
        /** rate (in bytes per second) at which sstable file deletions are limited to (under normal circumstances). */
        'target-byte-deletion-rate'?: number;
        /** target file size for the level 0 (default 2097152) */
        'target-file-size'?: number;
        /** if true same target-file-size will be uses for all levels, otherwise target size for layer n = 2 * target size for layer n - 1 */
        'target-file-size-equal-levels'?: boolean;
        /** number of bytes to write to a write-ahead log (WAL) before calling Sync on it in the background */
        'wal-bytes-per-sync'?: number;
        /** absolute path of directory to store write-ahead logs (WALs) in. If empty, WALs will be stored in the same directory as sstables */
        'wal-dir'?: string;
        /** minimum duration in microseconds between syncs of the WAL. If WAL syncs are requested faster than this interval, they will be artificially delayed. */
        'wal-min-sync-interval'?: number;
      };
      /** maximum number of concurrent compactions (default 16) */
      'max-concurrent-compactions'?: number;
      /** if true sync mode is used (data needs to be written to WAL before the write is marked as completed) */
      'sync-mode'?: boolean;
    };
  };
  /** 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;
      'redis-validation-server-config'?: {
        /** buffer reads (read next while working) (default true) */
        'buffer-reads'?: boolean;
        'consumer-config'?: {
          /** After a message spends this amount of time in PEL (Pending Entries List i.e claimed by another consumer but not Acknowledged) it will be allowed to be autoclaimed by other consumers (default 5m0s) */
          'idletime-to-autoclaim'?: string;
          /** timeout for response entry (default 1h0m0s) */
          'response-entry-timeout'?: string;
        };
        /** Supported module root hashes */
        'module-roots'?: string[];
        /** url of redis server */
        'redis-url'?: string;
        /** prefix for stream name */
        'stream-prefix'?: string;
        /** Timeout on polling for existence of redis streams (default 10m0s) */
        'stream-timeout'?: string;
        /** number of validation threads (0 to use number of CPUs) */
        'workers'?: number;
      };
      /** 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 execution time used by a jit wasm exceeds this limit, a rpc error is returned (default 10m0s) */
      'max-execution-time'?: string;
      /** 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 or mahcine base paths to match against on-chain WasmModuleRoot */
      '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;
  };
};