ethereumj.conf

peer.discovery = {

    # if peer discovery is on
    # the discovery protocol will be used to find other nodes and connect them
    # if peer discovery is off
    # this peer will only be connecting to the peers from [peer.active] list
    # inbound connections from other peers are accepted as well
    enabled = true

    # List of the seed peers to start
    # the search for online peers
    # values: [ip:port, enode://nodeid@ip:port, ip:port ...]
    ip.list = [
        # C++ Ethereum discovery nodes
        "5.1.83.226:30303",

        # Geth discovery nodes
        "52.16.188.185:30303",
        "13.93.211.84:30303",
        "191.235.84.50:30303",
        "13.75.154.138:30303",
        "52.74.57.123:30303",

        # Parity discovery nodes
        "193.70.55.37:30303",
        "144.217.139.5:30303",
        "139.99.51.203:30303",
        "139.99.160.213:30303",
        "163.172.131.191:30303",
        "212.47.247.103:30303",
        "163.172.157.114:30303"
        "138.201.223.35:30303",
        "138.201.144.135:30303",
        "51.15.42.252:30303",
        "163.172.171.38:30303"
        "163.172.187.252:30303",
        "136.243.154.244:30303",
        "88.212.206.70:30303",
        "37.128.191.230:30303",
        "46.20.235.22:30303",
        "216.158.85.185:30303",
        "52.79.241.155:30303",
        "52.78.149.82:30303",
    ]

    # external IP/hostname which is reported as our host during discovery
    # if not set, the service http://checkip.amazonaws.com is used
    # the last resort is to get the peer.bind.ip address
    external.ip = null

    # Local network adapter IP to which
    # the discovery UDP socket is bound
    # e.g: 192.168.1.104
    #
    # if the value is empty it will be retrieved
    # by punching to some known address e.g: www.google.com
    bind.ip = ""

    # indicates whether the discovery will include own home node
    # within the list of neighbor nodes
    public.home.node = true

    # indicates if the discovered nodes and their reputations
    # are stored in DB and persisted between VM restarts
    persist = true

    # the period in seconds with which the discovery
    # tries to reconnect to successful nodes
    # 0 means the nodes are not reconnected
    touchPeriod = 600

    # the maximum nuber of nodes to reconnect to
    # -1 for unlimited
    touchMaxNodes = 100

    # number of workers that
    # test the peers for being
    # online [1..10]
    workers = 8
}

peer {
    # Port on which ethereumj will listen
    # for incoming connections
    listen.port = 30303

    # Network id
    networkId = 1

    # Private key of the peer
    # The key is generated by default on the first run and stored in the database folder
    # If you have your own peer ID, specify its private key here
    # derived nodeId = dead745c1dbcde518b48e52aca1e8d5ba666005a2c8804e39826c6080fb11c1e8abe41d1e41896e871f204f790a90fa9781744cccecf492212192a7c56e7673b
    # privateKey = f67c4032a7ff79bbfa7a780331b235c4eb681d51a0704cb1562064fb6c4bced4

    # Boot node list
    active = [
        # Sample entries:
        # { url = "enode://<hex nodeID>@hostname.com:30303" }
        # {
        #    ip = hostname.com
        #    port = 30303
        #    nodeId = e437a4836b77ad9d9ffe73ee782ef2614e6d8370fcf62191a6e488276e23717147073a7ce0b444d485fff5a0c34c4577251a7a990cf80d8542e21b95aa8c5e6c
        # }
    ]

    # list of trusted peers from which incoming connections are always accepted
    trusted = [
        # Sample entries:
        # {nodeId = "e437a4836b77ad9d9ffe73ee782ef2614e6d8370fcf62191a6e488276e23717147073a7ce0b444d485fff5a0c34c4577251a7a990cf80d8542e21b95aa8c5e6c"},
        # {ip = "11.22.33.44"},
        # {ip = "11.22.33.*"},
        # {
        #   nodeId = "e437a4836b77ad9d9ffe73ee782ef2614e6d8370fcf62191a6e488276e23717147073a7ce0b444d485fff5a0c34c4577251a7a990cf80d8542e21b95aa8c5e6c"
        #   ip = "11.22.33.44"
        # }
    ]

    # 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

    # The protocols supported by peer
    # can be: [eth, shh, bzz]
    capabilities = [eth]

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

    # how much time [seconds]
    # we will wait for a message
    # to arrive before closing the channel
    channel.read.timeout = 30

    p2p {
        # the default version outbound connections are made with
        # inbound connections are made with the version declared by the remote peer (if supported)
        # version = 4

        # 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 folder resources/genesis
# contains several versions of
# genesis configuration according
# to the network the peer will run on
genesis = frontier.json

# path to genesis file
# has priority over `genesis` option
# genesisFile = /some/path/to/frontier.json

# Blockchain settings (constants and algorithms) which are
# not described in the genesis file (like MINIMUM_DIFFICULTY or Mining algorithm)
# The possible named presets are:
# - main : the main network (Frontier-Homestead-...)
# - ropsten: Ropsten test network
# - testnet: Ethercamp test network
# - olympic: pre-Frontier Olympic network
# For custom network settings please refer to 'blockchain.config.class'
blockchain.config.name = "main"

# This is a more advanced replacement for 'blockchain.config.name'
# Here the exact org.ethereum.config.BlockchainForkConfig implementation
# class name can be specified.
# Only one of two options (this and above) can be defined.
#blockchain.config.class = "org.ethereum.config.fork.MainForkConfig"

database {
    # place to save physical storage files
    # can be either absolute or relative path
    dir = database

    # every time the application starts
    # the existing database will be
    # destroyed and all the data will be
    # downloaded from peers again [true/false]
    reset = false

    # If reset=true, every time the application
    # starts the database will reset itself to
    # this block number and sync again from there.
    # Set to 0 for a 'full' reset.
    resetBlock = 0

    # every time the application starts
    # existing database will be restored from latest backup
    # this option is supported by RocksDB only
    fromBackup = false

    # handling incompatible database version:
    #  * EXIT   - (default) show error in std out and exit by throwing Error
    #  * RESET  - clear database directory and continue working
    #  * IGNORE - continue working regardless possible issues
    # @since 1.4.0
    incompatibleDatabaseBehavior = EXIT

    # controls state database pruning
    # pruned state consumes much less disk space (e.g. 50G full and 1G pruned)
    # but the state can be restored only within last [maxDepth] blocks, all older
    # states are lost
    prune {
        enabled = true

        # controls how much last block states are not pruned
        # it is not recommneded to set this value below 192
        # as it can prevent rebranching from long fork chains
        #
        # NOTE: the bigger this value is the larger memory footprint pruning has,
        # here are some milstones to get the idea of how large it can be:
        #       192: 10 Mb
        #     1_000: 16 Mb
        #    10_000: 58 Mb
        #   100_000: 718 Mb
        # 1_000_000: 5658 Mb
        maxDepth = 192
    }

    # defines a number of opened files by db instance
    # this number has significant impact on read amplification
    # on the other hand it can force exceeding of user's limit,
    # OS usually set it to 1024 for all applications
    maxOpenFiles = 512
}

# Cache settings
cache {

    flush {
        # size in Mbytes of the write buffer for all datasources (state, blocks, transactions)
        # data is flushed to DB when write caches size exceeds this limit
        # value < 0 disables this option
        writeCacheSize = 64

        # force data flush each N blocks
        # [10000 flush each 10000 blocks]
        # value 0 disables this option
        blocks = 0

        # flush each block after full (long) sync complete
        shortSyncFlush = true
    }

    # total size in Mbytes of the state DB read cache
    stateCacheSize = 384

    # the size of block queue cache to be imported in MBytes
    blockQueueSize = 32

    # the size of header queue cache during import in MBytes
    headerQueueSize = 8

    # maximum size (in Mb) the state bloom fiter can grow up to
    # when reaching this threshold the bloom filter
    # is turned off forever
    # 128M can manage approx up to 50M of db entries
    # DEPRECATED, states source is no more backed with bloom filter
    maxStateBloomSize = 128
}

# eth sync process
sync {

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

    # Fast sync options
    fast {

        # enables/disables fastsync
        # when enabling make sure the global sync option is enabled ('sync.enabled')
        enabled = false

        # when specified the fastsync retrieves the state for this block
        # this is the fast and secure option to do fastsync
        # if not specified the block is selected like [peerBestBlockNumber - 1000]
        //        pivotBlockHash = 6149ddfd7f52b2aa34a65b15ae117c269b5ff2dc58aa839dd015790553269411

        # create a backup when the state has been downloaded
        # this option is supported by RocksDB only
        backupState = false

        # skip bodies and receipts downloading for blocks prior to pivot
        # this option doesn't affect block headers
        skipHistory = false
    }

    # minimal peers count
    # used in sync process
    # sync may use more peers
    # than this value
    # but will try to get
    # at least this many from discovery
    peer.count = 30

    # Uncomment this param
    # to use a strict Eth version.
    # Useful for testing
    # version = 62

    # exit if we receive a block that causes state conflict
    # this option is mainly for debugging purposes
    exitOnBlockConflict = false

    # Make long sync done (switch to short sync) in XX seconds
    # if all known blocks already downloaded.
    # Useful in private networks where auto-switch could fail.
    # Recommended value for private networks: 60 (seconds)
    makeDoneByTimeout = -1

    # Ethash verification mode
    # fake   - run partial check without verification against Ethash dataset
    # strict - run full check for each block
    # mixed  - main import flow in short sync: run full check for each block,
    #          long sync, fast sync headers and blocks: run full check in random fashion (20% blocks are checked)
    ethash = mixed
}

# miner options
mine {

    # start mining blocks
    # when 'sync.enabled' is true the mining starts when the sync is complete
    # else the mining will start immediately, taking the best block from database
    # (or genesis if no blocks exist yet)
    start = false

    # number of CPU threads the miner will mine on
    # 0 disables CPU mining
    cpuMineThreads = 4

    # there two options for CPU mining 'light' and 'full'
    # 'light' requires only 16M of RAM but is much slower
    # 'full' requires 1G of RAM and possibly ~7min for the DataSet generation
    #   but is much faster during mining
    fullDataSet = true

    # mining beneficiary
    coinbase = "0000000000000000000000000000000000000000"

    # extra data included in the mined block
    # one of two properties should be specified
    extraData = "EthereumJ powered"
    #extraDataHex = "0102abcd"

    # transactions with the gas price lower than this will not be
    # included in mined blocks
    # decimal number in weis
    minGasPrice = 1000000000  # 1 Gwei

    # minimal timeout between mined blocks
    minBlockTimeoutMsec = 0

    # start mining with specific nonce (might be useful for testing)
    # null for random start nonce
    startNonce = null
}

# Solidity options
solc {
    # Full path to solc executable
    # If path is not provided, bundled Solidity Compiler is used
    path = null
}

# ========================================================
#    Debug and advanced options
# ========================================================

# the time we wait to the network
# to approve the transaction, the
# transaction got approved when
# include into a transactions msg
# retrieved from the peer [seconds]
transaction.approve.timeout = 15

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

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
  # styles: [pretty/standard+] (default: standard+)
  block = -1
  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.structured {
  trace = false
  dir = vmtrace
  compressed = true
  initStorageLimit = 10000
}

# make changes to tracing options
# starting from certain block
# -1 don't make any tracing changes
trace.startblock = -1

# enables/disables internal transactions data record
# a single transaction can potentially collect large amount
# of call data (especially in tests) so there is an option to disable it
record.internal.transactions.data = true

# invoke vm program on
# message received,
# if the vm is not invoked
# the balance transfer
# occurs anyway  [true/false]
play.vm = true

# hello phrase will be included in
# the hello message of the peer
hello.phrase = Dev

# this property used
# mostly for debug purposes
# so if you don't know exactly how
# to apply it, leave it as [-1]
#
# ADVANCED: if we want to load a root hash
# for db not from the saved block chain (last block)
# but any manual hash this property will help.
# values [-1] - load from db
#        [hex hash 32 bytes] root hash
root.hash.start = null

# Key value data source values: [rocksdb/leveldb/inmem]
# 'leveldb' option is meant to be DEPRECATED
keyvalue.datasource = rocksdb

record.blocks=false
blockchain.only=false

# Load the blocks
# from a rlp lines
# file and not for
# the net
blocks.loader=""

#crypto settings, such as sign, hash, etc
crypto {
	#JCA cryptoprovider name. 
	providerName="SC"
	#Used for create JCA MessageDigest
	hash.alg256="ETH-KECCAK-256"
	hash.alg512="ETH-KECCAK-512"
}