usc-sample.conf

blockchain.config.name = "main"

peer {

    discovery = {

        # if peer discovery is off
        # the peer window will show
        # only what retrieved by active
        # peer [true/false]
        enabled = true

        # List of the peers to start
        # the search of the online peers
        # values: [ip:port]
        ip.list = [
            "192.168.0.244:5858",
            "192.168.0.198:5858",
            "192.168.0.199:5858",
        ]
    }

    # Boot node list
    # Use to connect to specific nodes
    active = [
        {
            ip = 192.168.0.244
            port = 5858
            nodeId = 24835b5b2b0aa9d19aa62090359926cb2bddd6d7c46293204b3da1ae14a53e21a816d473ec2a1fd6b73a1f09053594350615ff4296b28632c93755723e2717c3
        }
    ]

    # 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 = "24835b5b2b0aa9d19aa62090359926cb2bddd6d7c46293204b3da1ae14a53e21a816d473ec2a1fd6b73a1f09053594350615ff4296b28632c93755723e2717c3"},
        # {ip = "11.22.33.44"},
        # {ip = "11.22.33.*"},
        # {
        #   nodeId = "e437a4836b77ad9d9ffe73ee782ef2614e6d8370fcf62191a6e488276e23717147073a7ce0b444d485fff5a0c34c4577251a7a990cf80d8542e21b95aa8c5e6c"
        #   ip = "11.22.33.44"
        # }
    ]

    # Port for server to listen for incoming connections
    # 5858 for mainnet
    port = 5858

    # 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 = 30

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

    # Network id
    networkId = 775

    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
    }

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

# Interface to bind peer discovery and wire protocol
# Make sure you are using the correct bind ip. Wildcard value: 0.0.0.0
bind_address = 0.0.0.0

# public IP/hostname which is reported as our host during discovery
# if not set, the service http://checkip.amazonaws.com is used.
# bind_address is the last resort for public ip when it cannot be obtained by other ways
# public.ip = google.com

# the folder resources/genesis contains several versions of genesis configuration according to the network the peer will run on
genesis = usc-mainnet.json

# 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 = 100

database {
    # place to save physical storage files
    dir = <DATABASE_PATH>

    # 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
}


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.structured {
    trace = false
    dir = vmtrace
    compressed = true
    initStorageLimit = 10000
}

# 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 = MainNet

# Key value data source values: [leveldb]
keyvalue.datasource = leveldb

# the parameter specify when exactly to switch managing storage of the account on autonomous db
details.inmemory.storage.limit = 1

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

    # 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

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

rpc {
    providers : {
        web: {
            cors: "*.usc.co",
            http: {
                enabled: true,
                bind_address: localhost,
                # hosts = ["localhost", "private.ip", "external.ip", "example.com", "www.example.com"]
                port: 58858,
            }
            ws: {
                enabled: true,
                bind_address: localhost,
                port: 58859,
            }
        }
    }

    # Enabled RPC Modules. If the module is NOT in the list, and mark as "enabled", the rpc calls will be discard.
    # It is possible to enable/disable a particular method in a module
    # {
    #  name: "evm",
    #  version: "1.0",
    #  enabled: "true",
    #  methods: {
    #  	enabled: [ "evm_snapshot", "evm_revert" ],
    #       disabled: [ "evm_reset", "evm_increaseTime" ]
    #  }
    # }
    modules = [
        {
            name: "eth",
            version: "1.0",
            enabled: "true",
        },
        {
            name: "net",
            version: "1.0",
            enabled: "true",
        },
        {
            name: "rpc",
            version: "1.0",
            enabled: "true",
        },
        {
            name: "web3",
            version: "1.0",
            enabled: "true",
        },
        {
            name: "evm",
            version: "1.0",
            enabled: "true"
        },
        {
            name: "sco",
            version: "1.0",
            enabled: "true",
        },
        {
            name: "txpool",
            version: "1.0",
            enabled: "true",
        },
        {
            name: "personal",
            version: "1.0",
            enabled: "true"
        }
    ]
}

# account loaded when the node start.
wallet {
    accounts = []
    enabled = false
}

wire {
    protocol: "usc"
}

# solc compiler path
solc.path = <SOLC_PATH>

# 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
	}
}

prune {
    # prune service could be enabled or not
    # values: [true/false]
    # default: false
    enabled = false

    # No of blocks to process
    blocks {
        # No of blocks to copy in each prune run
        # default: 5000
        toCopy = 5000

        # No of blocks to wait to run prune again
        # default: 10000
        toWait = 10000

        # No of blocks to suspend blockchain process
        # in order to avoid forks
        # default: 100
        toAvoidForks = 100
    }
}