reference.conf

blockchain = {
    config = {
        # Flag that forces to verify whether a node is started with unknown configuration property names.
        # Whole list of possible property names is defined in the expected.conf file.
        verify = false

        consensusRules = {
            areBridgeTxsPaid = afterBridgeSync,
            rskip85 = orchid,
            rskip87 = orchid,
            rskip88 = orchid,
            rskip89 = orchid,
            rskip90 = orchid,
            rskip91 = orchid,
            rskip92 = orchid,
            rskip97 = orchid,
            rskip98 = orchid,
            rskip103 = orchid060,
            rskip106 = wasabi100,
            rskip110 = wasabi100,
            rskip119 = wasabi100,
            rskip120 = wasabi100,
            rskip122 = wasabi100,
            rskip123 = wasabi100,
            rskip124 = wasabi100,
            rskip125 = wasabi100,
            rskip126 = wasabi100,
            rskip132 = wasabi100,
            rskip134 = papyrus200,
            rskip136 = bahamas,
            rskip137 = papyrus200,
            rskip140 = papyrus200,
            rskip143 = papyrus200,
            rskip146 = papyrus200,
            rskip150 = twoToThree,
            rskip151 = papyrus200,
            rskip152 = papyrus200
            rskip156 = papyrus200
            rskipUMM = papyrus200
            rskip153 = iris300
            rskip169 = iris300
            rskip170 = iris300
            rskip171 = iris300
            rskip174 = iris300
            rskip176 = iris300
            rskip179 = iris300
            rskip180 = iris300
            rskip181 = iris300
            rskip185 = iris300
            rskip186 = iris300
            rskip191 = iris300
            rskip197 = iris300
            rskip199 = iris300
            rskip200 = iris300
            rskip201 = iris300
            rskip218 = iris300
            rskip219 = iris300
            rskip220 = iris300
            rskip252 = fingerroot500
            rskip271 = hop400
            rskip284 = hop400
            rskip290 = hop400
            rskip293 = hop400
            rskip294 = hop400
            rskip297 = hop400
            rskip326 = fingerroot500
            rskip353 = hop401
            rskip357 = hop401
            rskip374 = fingerroot500
            rskip375 = fingerroot500
            rskip376 = tbd600
            rskip377 = fingerroot500
            rskip383 = fingerroot500
            rskip385 = fingerroot500
            rskip398 = tbd600
            rskip400 = tbd600
        }
    }
    gc = {
        enabled = false
        epochs = 3
        blocksPerEpoch = 20000
    }
    flushNumberOfBlocks = 1000
}

peer {
    # Boot node list
    # Use to connect to specific nodes
    active = [ ]

    # list of trusted peers the incoming connections is always accepted from. Even if the max amount of connections is reached
    # This is used to create a filter of Trusted peers
    trusted = [
        # Sample entries:
        # {nodeId = "e437a4836b77ad9d9ffe73ee782ef2614e6d8370fcf62191a6e488276e23717147073a7ce0b444d485fff5a0c34c4577251a7a990cf80d8542e21b95aa8c5e6c"},
        # {ip = "11.22.33.44"},
        # {ip = "11.22.33.*"},
        # {
        #   nodeId = "e437a4836b77ad9d9ffe73ee782ef2614e6d8370fcf62191a6e488276e23717147073a7ce0b444d485fff5a0c34c4577251a7a990cf80d8542e21b95aa8c5e6c"
        #   ip = "11.22.33.44"
        # }
    ]

    # connection timeout for trying to connect to a peer [seconds]
    connection.timeout = 2

    # the parameter specifies how much time we will wait for a message to come before closing the channel
    channel.read.timeout = 300

    # Private key of the peer
    # nodeId = <NODE_ID>
    # privateKey = <PRIVATE_KEY>

    p2p {
        # max frame size in bytes when framing is enabled
        framing.maxSize = 32768

        # forces peer to send Handshake message in format defined by EIP-8,
        # see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-8.md
        eip8 = true

        # the time in seconds to ping other peers on the network
        pingInterval = 5
    }

    # max number of active peers our node will maintain
    # extra peers trying to connect us will be dropped with TOO_MANY_PEERS message
    # the incoming connection from the peer matching 'peer.trusted' entry is always accepted
    maxActivePeers = 30

    # address blocks are defined to allow or restrict access from ip ranges
    filter {
        # max number of connections allowed on a single address block
        maxConnections = 16
        # the cidr bits used to define a subnet in IPV4 - i.e. 32 bits is a full address
        networkCidr = 16
    }

    discovery = {
        # allow multiple connections per host by default
        allowMultipleConnectionsPerHostPort = true
    }

    # flag that allows to propagate a received block without executing it and only checking basic validation rules.
    fastBlockPropagation = true

    # list of IPs of banned peers
    bannedPeerIPs = []

    # list of IDs of banned peers
    bannedPeerIDs = []

    # list of banned miners
    bannedMiners = []

    # Max number of pending messages that will be allowed per peer
    messageQueue.maxSizePerPeer = 2000

}

miner {
    # The default gas price
    minGasPrice = 0

    server {
        enabled = false
        isFixedClock = false

        # the number of milliseconds that should pass from a previous submission of a mining solution before next one is allowed
        # set this value to zero or any negative number to disable this limit
        workSubmissionRateLimitInMills = 0

        # Toggles the behaviour of the miner server to prepare a new work for the miners when the node gets a new pending transaction
        updateWorkOnNewTransaction = false
    }

    client {
        enabled = false

        # If autoMine is true, it will set delayBetweenBlocks in 0
        # otherwise it will use what is define in delayBetweenBlocks setting.
        autoMine = false

        # The time the miner client will wait after mining a block and before mining the next one.
        # This allows mining a sane number of blocks per minute when the difficulty is low (e.g. for regtest).
        delayBetweenBlocks = 0 seconds

        # The time the miner client will wait to refresh the current work from the miner server
        delayBetweenRefreshes = 1 second
    }
}

database {
    # every time the application starts the existing database will be destroyed and all the data will be downloaded from peers again
    # having this set on true does NOT mean that the block chain will start from the last point
    # [true/false]
    reset = false
    # a bootstrap file to accelerate synchronization process can be downloaded from a known source
    # having this set on true downloads this file and imports the data contained when the program starts
    # [true/false]
    import {
        enabled = false
        #url = ""
        trusted-keys = []
    }
}

# Interface to bind peer discovery and wire protocol
bind_address = 0.0.0.0

public {
    # public IP/hostname which is reported as our host during discovery.
    # if not set, the ipCheckService URL is used.
    # ip = google.com

    # The URL of a service returning our own public IP as the response body.
    # If multiple IPs are returned separated by commas (e.g Amazon returns X-Forwarded-For values) the last one is used
    # We have two fallback mechanisms in case this service is not working, in order of precedence:
    #       1) use bind_address property (only if not local)
    #       2) use hardcoded address "127.0.0.1" as last resort
    ipCheckService = "https://checkip.amazonaws.com"
}

# the number of blocks should pass before pending transaction is removed
transaction.outdated.threshold = 10

# the number of seconds should pass before pending transaction is removed
# (suggested value: 10 blocks * 10 seconds by block = 100 seconds)
transaction.outdated.timeout = 650

# the percentage increase of gasPrice defined to accept a new transaction
# with same nonce and sender while the previous one is not yet processed
transaction.gasPriceBump = 40

# number of slots for pending txs guaranteed per account in a tx pool
transaction.accountSlots = 16

# flag to enable rate-limit for accounts broadcasting transactions consuming large amounts of resources
transaction.accountTxRateLimit.enabled = true

# period after which TxQuotas will be cleaned, use 0 or negative values to disable this clean
transaction.accountTxRateLimit.cleanerPeriod = 30


dump {
    # for testing purposes all the state will be dumped in JSON form to [dump.dir] if [dump.full] = true
    # possible values [true/false]
    full = false

    dir = dmp

    # This defines the vmtrace dump to the console and the style
    # -1 for no block trace
    block = -1

    # styles: [pretty/standard+] (default: standard+)
    style = pretty

    # clean the dump dir each start
    clean.on.restart = true
}

# structured trace is the trace being collected in the form of objects and exposed to the user in json or any other convenient form
vm {
    executionStackSize = 4M
    structured {
        trace = false
        traceOptions = 0
        dir = vmtrace
        compressed = true
        initStorageLimit = 10000
    }
}
# This configuration value defines db kind which is used one time on db creation.
# To change db kind of an existing database, you will have to make a proper change in the configuration as well as drop the db.
# Key value data source values: [leveldb/rocksdb]
keyvalue.datasource = rocksdb

sync {
    # block chain synchronization can be: [true/false]
    enabled = true

    # Periodically check if peers send messages in order to determine if their connection should be kept or dropped
    heartBeat.enabled = false

    # maximum blocks hashes to ask sending GET_BLOCK_HASHES msg we specify number of block we want to get, recomended value [1..1000]
    # Default: unlimited
    max.hashes.ask = 10000

    # minimal peers count used in sync process sync may use more peers than this value but always trying to get at least this number from discovery
    peer.count = 10

    # The expected number of peers we would want to start finding a connection point.
    expectedPeers = 5

    # Timeout in minutes to start finding the connection point when we have at least one peer
    timeoutWaitingPeers = 1

    # Timeout in seconds to wait for syncing requests
    timeoutWaitingRequest = 30

    # Expiration time in minutes for peer status
    expirationTimePeerStatus = 10

    # Maximum amount of chunks included in a skeleton message
    maxSkeletonChunks = 20

    # Maximum amount of bodies to request at the same time when synchronizing backwards
    maxRequestedBodies = 20

    # Maximum allowed blocks of distance to the tip of the blockchain to prioritize forward synchronization
    longSyncLimit = 24

    # Amount of blocks contained in a chunk,
    # MUST BE 192 or a divisor of 192
    chunkSize = 192

    # X % of top best nodes will be considered when for random selection
    topBest = 0
}

rpc {
    callGasCap = 50000000
    # (experimental, OFF by default) RPC timeout in milliseconds. Disabled when it's zero.
    timeout = 0
    # Maximum Response size allowed in bytes. If value is  0 then there is no limit.
    maxResponseSize = 0

    providers {
        web {
            cors = "localhost"
            max_batch_requests_size = 100
            http {
                enabled = true
                bind_address = localhost
                # Hosts is the list of virtual host names allowed to interact with the JSON RPC
                # interface by checking the Host header of incoming requests. This whitelist is
                # intended to prevent DNS rebinding attacks.
                #
                # Setting it to `*` will allow interactions with any host and it will be enabled
                # by default.
                #
                # WARNING: it is highly recommended to disable wallet (within main.conf) while
                # hosts contains '*'
                #
                # This disables the protection, but can be useful in certain environments where
                # the clients don't have predictable host names, such as clouds. Disabling this
                # can be particularly risky if you run RSKj on a Desktop computer (where browsers could be targeted).
                # Allowing any host name in cloud environments should represent no risk in general.
                #
                # For more information, see: How your ethereum can be stolen through DNS rebinding:
                # https://blog.hacker.af/how-your-ethereum-can-be-stolen-using-dns-rebinding
                hosts = ["*"]
                port = 4444
                # A value greater than zero sets the socket value in milliseconds. Node attempts to gently close all
                # TCP/IP connections with proper half close semantics, so a linger timeout should not be required and
                # thus the default is -1.
                linger_time = -1
                max_aggregated_frame_size = 5242880 # 5 mb, a chunked request can accumulate data up to this frame size
            }
            ws {
                enabled = false
                bind_address = localhost
                port = 4445
                # Shuts down the server when it's not able to write a response after a certain period (expressed in seconds)
                server_write_timeout_seconds = 30
                max_aggregated_frame_size = 5242880 # 5 mb, a chunked request can accumulate data up to this frame size
                max_frame_size = 65536 # 64 kb, maximum supported frame size
            }
        }
    }
    # Enabled RPC Modules. If the module is NOT in the object, and mark as "enabled", the rpc calls will be discard.
    # It is possible to enable/disable a particular method in a module
    # evm {
    #  version: "1.0",
    #  enabled: "true",
    #  methods: {
    #      enabled: [ "evm_snapshot", "evm_revert" ],
    #      disabled: [ "evm_reset", "evm_increaseTime" ]
    #  }
    # }
    modules = {
        eth {
            version: "1.0",
            enabled: "true",
        },
        net {
            version: "1.0",
            enabled: "true",
        },
        rpc {
            version: "1.0",
            enabled: "true",
        },
        web3 {
            version: "1.0",
            enabled: "true",
        },
        evm {
            version: "1.0",
            enabled: "true",
        },
        sco {
            version: "1.0",
            enabled: "false",
        },
        txpool {
            version: "1.0",
            enabled: "true",
        },
        personal {
            version: "1.0",
            enabled: "true"
        },
        debug {
            version: "1.0",
            enabled: "false"
        },
        trace {
            version: "1.0",
            enabled: "false"
        },
        rsk {
            version: "1.0",
            enabled: "true",
            methods: {
                disabled: [ "rsk_shutdown", "rsk_flush" ]
            }
        }
    }
    skipRemasc: false
    # set signature to zero (instead of null) for Remasc transaction on RPC DTOs
    zeroSignatureIfRemasc = true
    gasEstimationCap = 6800000 # block gasLimit, rpc DoS protection for gas estimation
    logs {
        # maximum number of blocks to query
        maxBlocksToQuery = 0
        # maximum number of logs to return
        maxLogsToReturn = 0
    }
}

wire {
    protocol: "rsk"
}

# solc compiler path
solc.path = /bin/false

# not good reputation expiration time in seconds
scoring {
    # punishment by node id
    nodes {
        # number of nodes to keep scoring
        number: 100

        # initial punishment duration (in minutes, default = 10 minutes)
        duration: 12

        # punishment duration increment (in percentage, default = 10)
        increment: 10

        # maximum punishment duration (in minutes, default = 0 minutes, no maximum)
        maximum: 0
    }
    # punishment by address
    addresses {
        # initial punishment duration (in minutes, default = 10 minutes)
        duration: 12

        # punishment duration increment (in percentage, default = 10)
        increment: 10

        # maximum punishment duration (in minutes, default = 1 week)
        maximum: 6000
    }
    # punishment feature enabled
    punishmentEnabled = true

    summary = { # logs a report every specific time, as described in PeerScoringStatsReport
        enabled = true
        time = 300000 # every five minutes (in milliseconds)
    }
}

cache {
  states {
    # During the processing of a Raul's fully filled blockchain, the cache
    # is generating the following hits per block (average)
    # uncommitedCacheHits = 1340
    # commitedCacheHits = 248
    # Processing 134 blocks grows the commitedCache to 100K entries, or approximately
    # or 25 Mbytes. A cache of about 100 Mbytes seems rasonable. Anyway, for
    # precaution we'll set the limit to 100K entries.
    # Update: Tests confirmed that a value of 1M improves node performance
    max-elements: 1000000

    # enables persistence of states cache snapshots, which speeds up loading of trie nodes from a disk into memory
    persist-snapshot: true
  },
  stateRoots {
    # each entry represents a mapping between old state root hashes and new ones.
    # This mapping is only needed for blocks before the wasabi100 HF, that is [0 .. 1591000 -1] in mainnet.
    # initial estimated capacity: 4000 entries
    max-elements: 4000
  },
  receipts {
    # each entry represents a transaction with one or more receipts
    # initial estimated capacity: 100000 transactions
    # ie 200 transactions in 500 blocks
    max-elements: 100000
  },
  blooms {
    # each entry represents a range of blocks
    # initial estimated capacity: 100000 entries
    max-elements: 100000

    # (experimental, OFF by default) enables persistence of cache snapshots, which speeds up loading of entries from a disk into memory
    persist-snapshot: false
  },
  btcBlockStore {
    depth: 5000,
    size: 10000
  }
}

crypto {
    #Possibility to config crypto library implementation to use
    # Possible values:
    # - "bc" (Bouncy Castle)
    # - "native" (Native C lib)
    library: "native"
}

system {
    printInfo = false
}

blooms {
    blocks = 16
    service = false
    confirmations = 400
}