application.conf

bitcoin-s {
  network = mainnet # regtest, testnet3, mainnet, signet
  datadir = ${HOME}/.bitcoin-s

  dbDefault = {
    dataSourceClass = slick.jdbc.DatabaseUrlDataSource
    profile = "slick.jdbc.SQLiteProfile$"

    db {
      # for information on parameters available here see
      # https://scala-slick.org/doc/3.3.1/api/index.html#slick.jdbc.JdbcBackend$DatabaseFactoryDef@forConfig(String,Config,Driver,ClassLoader):Database
      path = ${bitcoin-s.datadir}/${bitcoin-s.network}/
      driver = org.sqlite.JDBC
      user = ""
      password = ""
      host = localhost
      port = 5432

      # this needs to be set to 1 for SQLITE as it does not support concurrent database operations
      # see: https://github.com/bitcoin-s/bitcoin-s/pull/1840
      numThreads = 1
      queueSize=5000
      connectionPool = "HikariCP"
      registerMbeans = true
    }
    hikari-logging = false
    hikari-logging-interval = 10 minute
  }

  node = ${bitcoin-s.dbDefault}

  node {
    peers = ["neutrino.suredbits.com:8333"] # a list of peer addresses in form "hostname:portnumber"
                          # (e.g. "neutrino.testnet3.suredbits.com:18333")
                          # Port number is optional, the default value is 8333 for mainnet,
                          # 18333 for testnet and 18444 for regtest.
    mode = neutrino # neutrino, spv
    # this config key is read by Slick
    db {
      name = nodedb
      poolName = "bitcoin-s-node-db"
    }
    # PostgreSQL example:
    # db {
    #   name = node
    #   driver = org.postgresql.Driver
    #   user = postgres
    #   password = ""
    # }
  }


  chain = ${bitcoin-s.dbDefault}
  chain {
    neutrino {
      filter-header-batch-size.default = 2000
      filter-header-batch-size.regtest = 10
      # You can set a network specific filter-header-batch-size
      # by adding a trailing `.networkId` (main, test, regtest)
      # It is recommended to keep the main and test batch size high
      # to keep the sync time fast, however, for regtest it should be small
      # so it does not exceed the chain size.

      filter-batch-size = 1000
    }
    # this config key is read by Slick
    db {
        name = chaindb
        poolName = "bitcoin-s-chain-db"
    }
    # PostgreSQL example:
    # db {
    #   name = chain
    #   driver = org.postgresql.Driver
    #   user = postgres
    #   password = ""
    # }
  }

  wallet = ${bitcoin-s.dbDefault}
    # settings for wallet module
  wallet {
      defaultAccountType = segwit # legacy, segwit, nested-segwit

      bloomFalsePositiveRate = 0.0001 # percentage

      addressGapLimit = 20

      discoveryBatchSize = 100

      requiredConfirmations = 6
      # How big the address queue size is before we throw an exception
      # because of an overflow
      addressQueueSize = 10

      # How long we attempt to generate an address for
      # before we timeout
      addressQueueTimeout = 5 seconds

    # this config key is read by Slick
    db {
      name = walletdb
      poolName = "bitcoin-s-wallet-db"
    }
    # PostgreSQL example:
    # db {
    #   name = wallet
    #   driver = org.postgresql.Driver
    #   user = postgres
    #   password = ""
    # }
  }

    server {
        # The port we bind our rpc server on
        rpcport = 9999
        rpcbind = "127.0.0.1"
    }

  dlc = ${bitcoin-s.dbDefault}
  dlc {
    # this config key is read by Slick
    db {
      name = dlcdb
      url = "jdbc:sqlite:"${bitcoin-s.dlc.db.path}${bitcoin-s.dlc.db.name}
    }
    # PostgreSQL example:
    # db {
    #   name = dlcdb
    #   driver = org.postgresql.Driver
    #   username = postgres
    #   password = ""
    # }
  }

  oracle = ${bitcoin-s.dbDefault}
  oracle {
    # this config key is read by Slick
    db {
      name = oracle
      path = ${bitcoin-s.datadir}/oracle/
      poolName = "bitcoin-s-oracle-db"
    }
    # PostgreSQL example:
    # db {
    #   name = oracle
    #   driver = org.postgresql.Driver
    #   user = postgres
    #   password = ""
    # }
  }

  test = ${bitcoin-s.dbDefault}
  test {
    # this config key is read by Slick
    db {
      name = testdb
    }
  }
}

akka {

  # Let Cli commands take 30 seconds
  http.server.request-timeout = 30s

  # Can parse 20MBs
  http.server.parsing.max-content-length = 20m
  http.client.parsing.max-content-length = 20m

  # Loggers to register at boot time (akka.event.Logging$DefaultLogger logs
  # to STDOUT)
  loggers = ["akka.event.slf4j.Slf4jLogger"]

  # Log level used by the configured loggers (see "loggers") as soon
  # as they have been started; before that, see "stdout-loglevel"
  # Options: OFF, ERROR, WARNING, INFO, DEBUG
  loglevel = "DEBUG"

  # Log level for the very basic logger activated during ActorSystem startup.
  # This logger prints the log messages to stdout (System.out).
  # Options: OFF, ERROR, WARNING, INFO, DEBUG
  stdout-loglevel = "DEBUG"

  # Filter of log events that is used by the LoggingAdapter before
  # publishing log events to the eventStream.
  logging-filter = "akka.event.slf4j.Slf4jLoggingFilter"

  use-slf4j = on

  log-config-on-start = off

    actor {
        debug {
            # enable DEBUG logging of all AutoReceiveMessages (Kill, PoisonPill etc.)
            autoreceive= off
            # enable function of LoggingReceive, which is to log any received message at
            # DEBUG level
            receive = on
            # enable DEBUG logging of unhandled messages
            unhandled = off

            # enable DEBUG logging of actor lifecycle changes
            lifecycle = off

            event-stream=off
        }
    }
}