gistfile1.txt

cat ./nxt-default.properties
################################################################################
# Copyright © 2013-2016 The Nxt Core Developers.                               #
#                                                                              #
# See the AUTHORS.txt, DEVELOPER-AGREEMENT.txt and LICENSE.txt files at        #
# the top-level directory of this distribution for the individual copyright    #
# holder information and the developer policies on copyright and licensing.    #
#                                                                              #
# Unless otherwise agreed in a custom licensing agreement, no part of the      #
# Nxt software, including this file, may be copied, modified, propagated,      #
# or distributed except according to the terms contained in the LICENSE.txt    #
# file.                                                                        #
#                                                                              #
# Removal or modification of this copyright notice is prohibited.              #
#                                                                              #
################################################################################

# Do not modify this file. Instead, create a nxt.properties file with only the
# properties you need to change, and set them there. The values in
# nxt.properties override those in nxt-default.properties.



#### SYSTEM ####

# Set the socks proxy host.
#socksProxyHost=localhost

# Set the socks proxy port.
#socksProxyPort=9050



#### PEER NETWORKING ####

# Announce my IP address/hostname to peers and allow them to share it with other
# peers. If disabled, peer networking servlet will not be started at all.
nxt.shareMyAddress=true

# Port for incoming peer to peer networking requests, if enabled.
nxt.peerServerPort=7874

# Enable UPnP for the peer port.
nxt.enablePeerUPnP=true

# UPnP gateway http read timeout, milliseconds. Set to -1 to disable.
# Default 7000 if not set.
#nxt.upnpGatewayTimeout=7000

# UPnP gateway socket connection timeout, milliseconds. Set to -1 to disable.
# Default 3000 if not set.
#nxt.upnpDiscoverTimeout=3000

# Host interface on which to listen for peer networking requests, default all.
# Use 0.0.0.0 to listen on all interfaces, including IPv6.
nxt.peerServerHost=0.0.0.0

# My externally visible IP address or host name, to be announced to peers.
# It can optionally include a port number, which will also be announced to
# peers, and may be different from nxt.peerServerPort (useful if you do port
# forwarding behind a router).
nxt.myAddress=

# My platform, to be announced to peers.
nxt.myPlatform=PC

# My hallmark, if available.
nxt.myHallmark=

# Default initial peers. Only used if nxt.usePeersDb=true.
# Do not modify. Add custom peers to nxt.wellKnownPeers instead.
nxt.defaultPeers=bug.airdns.org; 93.208.212.137; nxt6.y.cz; 104.193.41.253; \
  37.139.5.199; 109.230.224.89; 70.106.182.230; 77.144.105.130; 78.62.219.252; \
  68.168.161.160; 78.46.233.109; 120.25.65.184; nxt.cryonet.de; \
  111.192.141.164; 98.245.11.138; 100.34.247.56; 85.10.201.15; 05.zapto.org; \
  158.69.33.172; 78.47.58.62; 144.76.3.50; 192.99.77.148; 90.153.107.93; \
  76.79.201.54; 5.9.149.197; 81.2.103.237; 92.222.65.40; nxt4.y.cz; \
  178.62.225.240; 85.25.198.120; 185.99.132.54; 89.212.19.49; nxt01.now.im; \
  nrs.scripterron.org; 175.156.85.245; 62.227.10.194; 73.40.166.72; \
  217.23.6.2; 73.40.166.127; 174.140.167.239; 52.79.46.24; 162.243.242.8; \
  gunka.szn.dk; 128.199.46.72; 101.100.175.48; 76.176.202.107; 69.163.40.132; \
  192.0.226.19; 100.13.33.13; 94.227.33.223; 90.75.247.40; \
  raspi2nxtnode.ddns.net; nxt-001.nodes.be; 83.83.161.46; 91.121.150.75; \
  nxt3.y.cz; 80.153.101.190; 95.215.47.221; 86.206.97.98; 78.47.115.250; \
  52.29.122.21; nxt.sx; nxt.cybermailing.com; 5.230.145.165; 70.31.212.252; \
  188.243.4.139; 128.199.189.226; nxt.scriba.io; 174.17.156.59; 80.150.243.96; \
  51.254.99.240; pakisnxt.no-ip.org; enricoip.no-ip.biz; 50.27.137.177; \
  80.150.243.99; 211.149.213.86; 176.97.2.179; 198.46.193.111; 80.150.243.12; \
  176.9.138.21; 80.150.243.13; f376.ddns.net; 61.120.160.90; 52.28.97.208; \
  5.9.180.173; 77.123.252.71; 93.211.251.105; 79.159.11.14; 96.255.76.163; \
  langust.ddns.net; 73.50.115.206; 66.215.60.93; 69.137.154.114; \
  103.250.83.112; 46.101.112.58; 71.170.34.26; 176.97.2.141; \
  nxt1.testdruif.be; home.kaerner.net; nxt.bened.de; 78.46.160.9; \
  162.243.122.251; 178.15.99.67; 78.46.49.59:4509; 93.219.103.107; \
  78.63.207.76; 198.211.127.34; 5.9.155.145; nxt.ydns.eu; 87.138.143.21; \
  77.152.74.54; 198.199.95.15; 46.223.83.130; 103.250.83.127; 91.210.188.6; \
  87.139.122.48; nxt1.y.cz; 113.106.85.172; 37.97.136.254; 87.139.122.157; \
  94.102.50.75; 70.189.162.138; 79.167.162.77; ct.flipflop.mooo.com; \
  51.255.149.237; 174.91.212.242; petko.ddns.net; 181.47.183.188; 93.75.9.10; \
  176.94.115.161; 91.235.72.49; 71.60.182.55; nxtcoin.no-ip.org; 91.239.69.78; \
  2.218.35.177; 46.4.74.71; 162.243.145.83; 94.102.50.68; 14.200.253.61; \
  nxtpeers.com; 192.3.196.10; 80.98.81.73; nxt2.testdruif.be; 77.88.208.12; \
  84.252.21.155; 158.69.194.254; 23.94.134.161; 96.236.141.73; 142.4.218.174; \
  72.182.27.227; 178.33.203.157; nxt.noip.me; 176.31.167.127; sluni.szn.dk; \
  198.27.81.25; 216.119.150.238; 71.218.89.236; 190.10.9.166; 166.48.75.119; \
  megaman.thican.net; 88.163.78.131; 132.230.76.160; 54.213.222.141; \
  humanoide.thican.net; 106.187.102.227; 96.236.143.175; 217.26.24.27; \
  184.191.182.165; 52.0.72.67; 104.130.7.74; 62.85.20.37; 82.165.138.42;

# A list of well known peer addresses / host names, separated by '; '. These
# peers are always kept in connected state.
nxt.wellKnownPeers=

# Known bad peers to be blacklisted.
nxt.knownBlacklistedPeers=

# Default initial peers used for testnet only. Only used if nxt.usePeersDb=true.
# Do not modify. Add custom testnet peers to nxt.testnetPeers instead.
nxt.defaultTestnetPeers=174.140.168.136; 52.20.125.165; nxt.noip.me; \
  89.212.19.49; bug.airdns.org;

# Well known testnet peers.
nxt.testnetPeers=

# Maximum number of inbound connections.
nxt.maxNumberOfInboundConnections=250

# Maximum number of outbound connections.
nxt.maxNumberOfOutboundConnections=50

# Maintain active connections with at least that many peers.
nxt.maxNumberOfConnectedPublicPeers=20

# Stop adding new peers when number of known peers exceeds that many.
nxt.maxNumberOfKnownPeers=2000

# Stop removing old peers when number of known peers drops below that many.
nxt.minNumberOfKnownPeers=1000

# Peer networking connect timeout for outgoing connections.
nxt.connectTimeout=10000

# Peer networking read timeout for outgoing connections.
nxt.readTimeout=20000

# Peer networking server idle timeout, milliseconds.
nxt.peerServerIdleTimeout=30000

# Use WebSocket connection if supported by the remote peer.
nxt.useWebSockets=true

# WebSocket connection idle timeout (milliseconds).
nxt.webSocketIdleTimeout=900000

# Use the peer hallmark to only connect with peers above the defined push/pull
# hallmark thresholds.
# Disabling hallmark protection also disables weighting of peers by hallmark
# weight, so connecting to any of your peers becomes equally likely.
nxt.enableHallmarkProtection=true

# Hallmark threshold to use when sending data to peers.
nxt.pushThreshold=0

# Hallmark threshold to use when requesting data from peers.
nxt.pullThreshold=0

# Blacklist peers for 600000 milliseconds (i.e. 10 minutes by default).
nxt.blacklistingPeriod=600000

# Consider a new transaction or block sent after 10 peers have received it.
nxt.sendToPeersLimit=10

# Enable the Jetty Denial of Service Filter for the peer networking server.
nxt.enablePeerServerDoSFilter=true

# Compress Http responses for the peer networking server.
nxt.enablePeerServerGZIPFilter=true

# Use testnet, leave set to false unless you are really testing.
# Never unlock your real accounts on testnet! Use separate accounts for testing
# only.
# When using testnet, all custom port settings will be ignored,
# and hardcoded ports of 6874 (peer networking), 6875 (UI) and 6876 (API) will
# be used.
nxt.isTestnet=false

# Save known peers in the database
nxt.savePeers=true

# Set to false to disable use of the peers database and the default initial
# peers. This will not delete saved peers.
nxt.usePeersDb=true

# Set to false to disable getting more peers from the currently connected peers.
# Only useful when debugging and want to limit the peers to those in peersDb or
# wellKnownPeers.
nxt.getMorePeers=true

# Set to true to run offline - do not connect to peers and do not listen for
# incoming peer connections. This is equivalent to setting
# nxt.shareMyAddress=false, nxt.wellKnownPeers=, nxt.testnetPeers=
# and nxt.usePeersDb=false, and if set to true overrides those properties.
nxt.isOffline=false

# Ignore peer announced addresses. Do not change unless you understand what it
# does.
nxt.ignorePeerAnnouncedAddress=false

# Only allow peer addresses starting with "fc". This is for users of cjdns only,
# do not set if you don't know what that is.
nxt.cjdnsOnly=false

# Do not include exception details when returning error response to peers.
nxt.hideErrorDetails=false



#### API SERVER ####

# Accept http/json API requests.
nxt.enableAPIServer=true

# Hosts from which to allow http/json API requests, if enabled. Set to * to
# allow all. Can also specify networks in CIDR notation, e.g. 192.168.1.0/24.
nxt.allowedBotHosts=127.0.0.1; localhost; [0:0:0:0:0:0:0:1];

# Port for http/json API requests.
nxt.apiServerPort=7876

# Port for https/json API request. If same as nxt.apiServerPort, the nxt.apiSSL
# setting determines whether SSL is used or not.
nxt.apiServerSSLPort=7876

# Enable UPnP for the API ports.
nxt.enableAPIUPnP=false

# Host interface on which to listen for http/json API request, default localhost
# only. Set to 0.0.0.0 to allow the API server to accept requests from all
# network interfaces, including IPv6.
nxt.apiServerHost=127.0.0.1

# Idle timeout for http/json API request connections, milliseconds.
nxt.apiServerIdleTimeout=30000

# Directory with html and javascript files for the new client UI, and admin
# tools utilizing the http/json API.
nxt.apiResourceBase=html/ui

# Default page for the API server.
nxt.apiWelcomeFile=index.html

# Java API documentation directory, optional.
nxt.javadocResourceBase=html/doc

# Enable Cross Origin Filter for the API server.
nxt.apiServerCORS=false

# Add X-Frame-Options SAMEORIGIN header to every response as a protection
# against clickjacking.
nxt.apiFrameOptionsSameOrigin=true

# Enable SSL for the API server (also need to set nxt.keyStorePath and
# nxt.keyStorePassword).
# Non-SSL connections will be disabled if nxt.apiServerSSLPort is equal to
# nxt.apiServerPort.
# Otherwise, both SSL and non-SSL connections will be accepted.
nxt.apiSSL=false

# Enforce requests that require POST to only be accepted when submitted as POST.
nxt.apiServerEnforcePOST=true

# Compress Http responses for the API server.
nxt.enableAPIServerGZIPFilter=false

# Password that should be provided when executing protected (administrative) API
# requests.
# Please choose a decent password here. Preferably, use a password generator.
# Password protection is disabled and password is not needed when the API server
# only listens on the localhost interface, i.e. when
# nxt.apiServerHost=127.0.0.1.
nxt.adminPassword=

# Set to true to disable the password protection for admin API requests even
# when API server is publicly accessible. Not recommended.
nxt.disableAdminPassword=false

# The maximum number of records possible to retrieve with a single request. This
# restriction is not enforced if the admin password is provided, or is not
# needed (disabled or listening on localhost only).
nxt.maxAPIRecords=100

# API event registration timeout (seconds). The timeout is reset each time an
# event wait request is received from the application. The minimum value is 15
# seconds.
nxt.apiEventTimeout=300

# Maximum number of applications with active event registrations.
nxt.apiMaxEventUsers=32

# Maximum file size accepted for upload, in bytes. Default and minimum value
# accepted is 43008 (42 kbytes).
#nxt.maxUploadFileSize=0

# If an unsigned transaction is submitted with insufficient fee, set the fee to
# the minimum fee calculated for this transaction instead, as if feeNQT=0 has
# been specified. Default is false.
nxt.correctInvalidFees=false

# APIs to disable, as a semicolon separated list.
nxt.disabledAPIs=

# Groups of APIs to disable, as a semicolon separated list of API tag names.
nxt.disabledAPITags=



#### OLD NRS USER INTERFACE ####

# Enable the deprecated NRS user interface.
nxt.enableUIServer=false

# Hosts from which to allow NRS user interface requests, if enabled. Set to * to
# allow all.
nxt.allowedUserHosts=127.0.0.1; localhost; [0:0:0:0:0:0:0:1];

# Port for NRS user interface server.
nxt.uiServerPort=7875

# Host interface for NRS user interface server, default localhost only.
# Set to 0.0.0.0 to allow the UI to be accessed on all network interfaces.
nxt.uiServerHost=127.0.0.1

# Idle timeout for NRS user interface server, milliseconds.
nxt.uiServerIdleTimeout=30000

# Directory with html and javascript files for the NRS client user interface.
nxt.uiResourceBase=html/nrs

# Enable Cross Origin Filter for NRS user interface server.
nxt.uiServerCORS=false

# Enable SSL for the NRS user interface (also need to set nxt.keyStorePath and
# nxt.keyStorePassword).
nxt.uiSSL=false

# Enforce requests that require POST to only be accepted when submitted as POST.
nxt.uiServerEnforcePOST=true



#### DEBUGGING ####

# Log file, will be overwritten at every restart.
#nxt.log=nxt.log
# The log file is now specified in logging.properties.

# Enable debug log output.
#nxt.debug=false
# Debug logging is now specified in logging properties.

# Include caller traceback in log messages.
nxt.enableLogTraceback=false

# Enable logging of exception stack traces.
nxt.enableStackTraces=true

# Enable logging of Jetty messages.
#nxt.debugJetty=false
# Jetty logging is now specified in logging properties.

# Used for debugging peer to peer communications.
nxt.communicationLoggingMask=0

# Track balances of the following accounts and related events for debugging
# purposes.
nxt.debugTraceAccounts=

# File name for logging tracked account balances.
nxt.debugTraceLog=nxt-trace.csv

# Separator character for trace log.
nxt.debugTraceSeparator=\t

# Quote character for trace log.
nxt.debugTraceQuote="

# Log changes to unconfirmed balances.
nxt.debugLogUnconfirmed=false



#### DATABASE ####

# Database connection JDBC url, see the H2 documentation for possible
# customizations.
# Append ;AUTO_SERVER=TRUE to enable automatic mixed mode access.
# The nxt_db folder is expected to be in the current working directory, will be
# created if missing.
# nxt.dbUrl=jdbc:h2:./nxt_db/nxt;DB_CLOSE_ON_EXIT=FALSE;MVCC=TRUE;MV_STORE=FALSE

# Database connection JDBC url to use with the test network, if isTestnet=true.
# nxt.testDbUrl=jdbc:h2:./nxt_test_db/nxt;DB_CLOSE_ON_EXIT=FALSE;MVCC=TRUE;MV_STORE=FALSE

nxt.dbType=h2
nxt.testDbType=h2

nxt.dbDir=./nxt_db/nxt
nxt.testDbDir=./nxt_test_db/nxt

nxt.dbParams=DB_CLOSE_ON_EXIT=FALSE;MVCC=TRUE;MV_STORE=FALSE
nxt.testDbParams=DB_CLOSE_ON_EXIT=FALSE;MVCC=TRUE;MV_STORE=FALSE

nxt.dbUsername=sa
nxt.testDbUsername=sa

nxt.dbPassword=sa
nxt.testDbPassword=sa

# Database connection timeout in seconds.
nxt.dbLoginTimeout=70

# Database default lock timeout in seconds.
nxt.dbDefaultLockTimeout=60

# Maximum simultaneous database connections.
nxt.maxDbConnections=30

# The memory allocated to database cache, in kB.
# If set to 0, the cache size varies from a minimum of 16MB for heap sizes 160MB
# or less, to a maximum of 256MB for heap sizes 640MB or higher.
nxt.dbCacheKB=0

# Enable trimming of derived objects tables. Disabling this will significantly
# worsen performance.
nxt.trimDerivedTables=true

# If trimming is enabled, maintain enough previous height records to allow
# rollback of at least that many blocks. Cannot be set to less than 720.
# After increasing this value, a full re-scan also needs to be done in order for
# the previously trimmed records to be re-created and preserved.
nxt.maxRollback=800

# When trimming is enabled, it is run every nxt.trimFrequency blocks.
nxt.trimFrequency=1000

# Override the lifetime of prunable data to keep them longer, value in seconds.
# Set to -1 to disable pruning. Has no effect if set to less then the minimum
# required lifetime of two weeks (1209600 seconds) on mainnet, or 24 hours
# (86400 seconds) on testnet. Default is 90 days.
nxt.maxPrunableLifetime=7776000

# Include expired prunable parts if requested as long as it is still available.
# In order to provide the PRUNABLE peer service, nxt.maxPrunableLifetime must
# be -1 and nxt.includeExpiredPrunable must be true.  The PRUNABLE service means
# the peer will provide expired prunable data to other peers when requested.
nxt.includeExpiredPrunable=true

# Threshold for logging database statements (milliseconds).
nxt.statementLogThreshold=10000

# Threshold for logging database transactions (milliseconds).
nxt.transactionLogThreshold=15000

# Log the average transaction time after this many minutes.
nxt.transactionLogInterval=15

# Public keys are by default cached, which consumes 10-15 MB of memory.
nxt.enablePublicKeyCache=true



#### Blocks and transactions ####

# Delay generation of next block in order to accumulate more transactions in it.
# Waiting for much more than 15 s is not useful as transactions are allowed at
# most 15 s timestamp difference from the block they can be included in.
nxt.forgingDelay=20

# Generate and submit the next block before its hit time in response to
# receiving a lower difficulty block. Submitting the block more than 15 s before
# its time however will lead to its rejection.
nxt.forgingSpeedup=3

# Maximum number of forging accounts allowed on this node.
nxt.maxNumberOfForgers=100

# Verify batches of blocks downloaded from a single peer with that many other
# peers.
nxt.numberOfForkConfirmations=2
nxt.testnetNumberOfForkConfirmations=1

# Enable re-broadcasting of new transactions until they are received back from
# at least one peer, or found in the blockchain. This feature can optionally be
# disabled, to avoid the risk of revealing that this node is the submitter of
# such re-broadcasted new transactions.
nxt.enableTransactionRebroadcasting=true

# Do not allow the number of unconfirmed transactions in memory to exceed this
# value. If exceeded, the same transaction ordering as when choosing which
# transactions to include in a forged block is used to decide which to keep in
# the unconfirmed pool.
# Set to 0 or negative for no limit.
nxt.maxUnconfirmedTransactions=2000



#### ACCOUNT LEDGER ####

# Address of accounts (in RS format) to track balance changes in the ledger
# table, separated by ';'.
# Set to * to track changes for all accounts. Specify no accounts to disable
# the account ledger.
nxt.ledgerAccounts=*

# Specify 0 to not log unconfirmed changes, 1 to log unconfirmed changes or 2 to
# log only unconfirmed changes.
nxt.ledgerLogUnconfirmed=2

# Specify the number of blocks to keep when trimming the account ledger table.
# A value of zero will cause all blocks to be kept.
nxt.ledgerTrimKeep=30000



#### VOTING SYSTEM ####

# If disabled, polls are not processed at finish height and results are not
# stored in the database. When requested, poll results will be calculated
# on-the-fly, if the votes are still available.
nxt.processPolls=true



#### MINT ####

# Address of the NXT server to which the mint worker submits its transactions
# (default: localhost).
nxt.mint.serverAddress=

# Use Https when connecting to the server. Note that mint worker accepts any SSL
# certificate as valid, without checking hostname or certificate authority,
# therefore this will not protect you against a man-in-the-middle attack when
# submitting mint transactions.
nxt.mint.useHttps=false

# Specify a mintable currency code.
nxt.mint.currencyCode=

# Secret phrase for the minting account, this secret phrase is sent to the host
# specified by nxt.mint.serverAddress therefore do not specify secret phrase of
# an account with lots of funds.
nxt.mint.secretPhrase=

# Number of units to mint per transaction.
# The minting difficulty grows linearly with the number of units per mint.
nxt.mint.unitsPerMint=1

# The initial nonce used for minting.
# Set to 0 to start with a random nonce.
nxt.mint.initialNonce=0

# Number of concurrency threads used for minting.
# Set to 0 allocate one thread per processor core.
nxt.mint.threadPoolSize=0

# When set to false mint transactions are not submitted when a hash is solved.
# Set this value to true to perform actual minting.
nxt.mint.isSubmitted=false

# When set to false the mint worker will resume operation even in case a mint
# transaction has returned an error response.
nxt.mint.stopOnError=false



#### Shuffling ####

# Delete finished shufflings and their participants. When enabled, records of
# completed shufflings and their participants are deleted after the shuffling
# has finished, which will improve performance by keeping their tables smaller.
nxt.deleteFinishedShufflings=false

# Use strong secure random implementation. As this can block on unix systems,
# it is disabled by default. Enable only if using haveged or other entropy
# source that makes reading from /dev/random fast, otherwise server-side
# encryption will be unusably slow and cause coin shufflings to fail.
nxt.useStrongSecureRandom=false

# Maximum number of shufflers allowed to run at the same time on this node.
nxt.maxNumberOfShufflers=100



#### JETTY ####

# Settings for the Jetty Denial Of Service Filter, used for the peer networking
# server only.
nxt.peerServerDoSFilter.maxRequestsPerSec=30
nxt.peerServerDoSFilter.delayMs=1000
nxt.peerServerDoSFilter.maxRequestMs=300000

# keystore file and password, required if uiSSL or apiSSL are enabled.
nxt.keyStorePath=keystore
nxt.keyStorePassword=password



#### Developers only ####

# Force re-validation of blocks and transaction at start.
nxt.forceValidate=false

# Force re-build of derived objects tables at start.
nxt.forceScan=false

# Scale epoch time for faster forging. Only works when offline.
# nxt.timeMultiplier=1

# NRS version.
nxt.version=1.7.5