[Question] How to connect light-client-js to local dev node?

[tea2x]

https://github.com/nervosnetwork/ckb-light-client?tab=readme-ov-file#how-to-run

I followed above section, assuming it's similar to light-client.

Here's my dev node local_node_info:

{
  "jsonrpc": "2.0",
  "result": {
    "active": true,
    "addresses": [
      {
        "address": "/ip4/0.0.0.0/tcp/8115",
        "score": "0x1"
      }
    ],
    "connections": "0x0",
    "node_id": "QmWU9CWxK6yjzcfAbnUL8xdr54DSbYpwLDYew3gJm6WgGJ",
    "protocols": [
      {
        "id": "0x64",
        "name": "/ckb/syn",
        "support_versions": [
          "2",
          "3"
        ]
      },
      {
        "id": "0x67",
        "name": "/ckb/relay3",
        "support_versions": [
          "2",
          "3"
        ]
      },
      {
        "id": "0x79",
        "name": "/ckb/filter",
        "support_versions": [
          "2",
          "3"
        ]
      },
      {
        "id": "0x66",
        "name": "/ckb/tim",
        "support_versions": [
          "2",
          "3"
        ]
      },
      {
        "id": "0x78",
        "name": "/ckb/lightclient",
        "support_versions": [
          "2",
          "3"
        ]
      },
      {
        "id": "0x6e",
        "name": "/ckb/alt",
        "support_versions": [
          "2",
          "3"
        ]
      },
      {
        "id": "0x2",
        "name": "/ckb/identify",
        "support_versions": [
          "2",
          "3"
        ]
      },
      {
        "id": "0x0",
        "name": "/ckb/ping",
        "support_versions": [
          "2",
          "3"
        ]
      },
      {
        "id": "0x1",
        "name": "/ckb/discovery",
        "support_versions": [
          "2",
          "2.1",
          "3"
        ]
      },
      {
        "id": "0x3",
        "name": "/ckb/flr",
        "support_versions": [
          "2",
          "3"
        ]
      },
      {
        "id": "0x4",
        "name": "/ckb/disconnectmsg",
        "support_versions": [
          "2",
          "3"
        ]
      }
    ],
    "version": "0.114.0 (0c8711e 2024-02-29)"
  },
  "id": 1
}

Here's how i start the light client js:

      await this.client.start(
        { type: "TestNet", config },
        secretKey as Hex,
        "info",
        "wss"
      );

Here's the light-client-js network config:

# chain = "mainnet"
# chain = "testnet"
# chain = "your_path_to/dev.toml"
chain = "../../../NERVOS/ckb-dev-chain/specs/dev.toml"

[store]
path = "data/store"

[network]
path = "data/network"

listen_addresses = ["/ip4/0.0.0.0/tcp/8110"]
### Specify the public and routable network addresses
# public_addresses = []

# Node connects to nodes listed here to discovery other peers when there's no local stored peers.
# When chain.spec is changed, this usually should also be changed to the bootnodes in the new chain.
bootnodes = [
    "/ip4/127.0.0.1/tcp/8115/p2p/QmWU9CWxK6yjzcfAbnUL8xdr54DSbYpwLDYew3gJm6WgGJ"
]

### Whitelist-only mode
# whitelist_only = false
### Whitelist peers connecting from the given IP addresses
# whitelist_peers = []

### Enable `SO_REUSEPORT` feature to reuse port on Linux, not supported on other OS yet
# reuse_port_on_linux = true

max_peers = 125
max_outbound_peers = 1
# 2 minutes
ping_interval_secs = 120
# 20 minutes
ping_timeout_secs = 1200
connect_outbound_interval_secs = 15
# If set to true, try to register upnp
upnp = false
# If set to true, network service will add discovered local address to peer store, it's helpful for private net development
discovery_local_address = false
# If set to true, random cleanup when there are too many inbound nodes
# Ensure that itself can continue to serve as a bootnode node
bootnode_mode = false

[rpc]
# Light client rpc is designed for self hosting, exposing to public network is not recommended and may cause security issues.
# By default RPC only binds to localhost, thus it only allows accessing from the same machine.
listen_address = "127.0.0.1:9000"

When I use /ip4/127.0.0.1/tcp/8115/p2p/QmWU9CWxK6yjzcfAbnUL8xdr54DSbYpwLDYew3gJm6WgGJ as the boot node in the network config I get:

WebSocket connection to 'wss://127.0.0.1:8115/' failed:

What's the probable cause to this connection failure?
Or any suggestion to achieve connecting ckb-light-client-js to a local dev node?

[Officeyutong]

Local dev node should listen to a websocket address like /dns4/127.0.0.1/tcp/443/ws/p2p/QmX5D6aJiAQ5Fxn4BfVqSn6zrgyuQM1oXVC9yvmzLuHXnx, and light client should use websocket addresses to connect to local node.

Also, if you are using WebSocket (not WebSocket over TLS), the last argument of LightClient.start should be ws

      await this.client.start(
        { type: "TestNet", config },
        secretKey as Hex,
        "info",
        "ws"
      );

[tea2x]

I tried again but it seems the connection still doesn't make:

Here's how i start the light client:

      await this.client.start(
        { type: IS_MAIN_NET ? "MainNet" : "TestNet", config },
        secretKey as Hex,
        "info",
        "ws"
      );

Here's the network config, this time tried to set discovery_local_address = true:

# chain = "mainnet"
# chain = "testnet"
# chain = "your_path_to/dev.toml"
chain = "../../../NERVOS/ckb-dev-chain/specs/dev.toml"

[store]
path = "data/store"

[network]
path = "data/network"

listen_addresses = ["/ip4/0.0.0.0/tcp/8110"]
### Specify the public and routable network addresses
# public_addresses = []

# Node connects to nodes listed here to discovery other peers when there's no local stored peers.
# When chain.spec is changed, this usually should also be changed to the bootnodes in the new chain.
bootnodes = [
    "/dns4/127.0.0.1/tcp/8115/ws/p2p/QmWU9CWxK6yjzcfAbnUL8xdr54DSbYpwLDYew3gJm6WgGJ"
]

### Whitelist-only mode
# whitelist_only = false
### Whitelist peers connecting from the given IP addresses
# whitelist_peers = []

### Enable `SO_REUSEPORT` feature to reuse port on Linux, not supported on other OS yet
# reuse_port_on_linux = true

max_peers = 125
max_outbound_peers = 1
# 2 minutes
ping_interval_secs = 120
# 20 minutes
ping_timeout_secs = 1200
connect_outbound_interval_secs = 15
# If set to true, try to register upnp
upnp = false
# If set to true, network service will add discovered local address to peer store, it's helpful for private net development
discovery_local_address = true
# If set to true, random cleanup when there are too many inbound nodes
# Ensure that itself can continue to serve as a bootnode node
bootnode_mode = false

[rpc]
# Light client rpc is designed for self hosting, exposing to public network is not recommended and may cause security issues.
# By default RPC only binds to localhost, thus it only allows accessing from the same machine.
listen_address = "127.0.0.1:9000"

Ports are open and listening:

ckb-dev-chain $ ps                                      
  PID TTY           TIME CMD
 1889 ttys000    0:00.95 -zsh
69283 ttys000    0:00.15 npm run start:web   
69299 ttys000    0:13.16 webpack    
15421 ttys001    0:00.64 -zsh
 2587 ttys002    0:00.72 -zsh
20898 ttys003    0:01.20 -zsh
21234 ttys005    0:00.10 /bin/zsh -l
52494 ttys006    0:00.73 -zsh
68023 ttys006    1:12.57 ckb run
68024 ttys006    0:08.73 ckb miner
61381 ttys013    0:00.19 /bin/zsh -il
ckb-dev-chain $ lsof -nP -iTCP -sTCP:LISTEN | grep 68023
ckb       68023 tung   12u  IPv4 0x6929b9c90b8f15be      0t0  TCP *:8115 (LISTEN)
ckb       68023 tung  165u  IPv4 0xf0c8233a3a7a25ca      0t0  TCP 127.0.0.1:8114 (LISTEN)

[Officeyutong]

I tried again but it seems the connection still doesn't make:

Here's how i start the light client:

  await this.client.start(
    { type: IS_MAIN_NET ? "MainNet" : "TestNet", config },
    secretKey as Hex,
    "info",
    "ws"
  );

Here's the network config, this time tried to set discovery_local_address = true:

chain = "mainnet"

chain = "testnet"

chain = "your_path_to/dev.toml"

chain = "../../../NERVOS/ckb-dev-chain/specs/dev.toml"

[store]
path = "data/store"

[network]
path = "data/network"

listen_addresses = ["/ip4/0.0.0.0/tcp/8110"]

Specify the public and routable network addresses

public_addresses = []

Node connects to nodes listed here to discovery other peers when there's no local stored peers.

When chain.spec is changed, this usually should also be changed to the bootnodes in the new chain.

bootnodes = [
"/dns4/127.0.0.1/tcp/8115/ws/p2p/QmWU9CWxK6yjzcfAbnUL8xdr54DSbYpwLDYew3gJm6WgGJ"
]

Whitelist-only mode

whitelist_only = false

Whitelist peers connecting from the given IP addresses

whitelist_peers = []

Enable SO_REUSEPORT feature to reuse port on Linux, not supported on other OS yet

reuse_port_on_linux = true

max_peers = 125
max_outbound_peers = 1

2 minutes

ping_interval_secs = 120

20 minutes

ping_timeout_secs = 1200
connect_outbound_interval_secs = 15

If set to true, try to register upnp

upnp = false

If set to true, network service will add discovered local address to peer store, it's helpful for private net development

discovery_local_address = true

If set to true, random cleanup when there are too many inbound nodes

Ensure that itself can continue to serve as a bootnode node

bootnode_mode = false

[rpc]

Light client rpc is designed for self hosting, exposing to public network is not recommended and may cause security issues.

By default RPC only binds to localhost, thus it only allows accessing from the same machine.

listen_address = "127.0.0.1:9000"
Ports are open and listening:

ckb-dev-chain $ ps                                      
  PID TTY           TIME CMD
 1889 ttys000    0:00.95 -zsh
69283 ttys000    0:00.15 npm run start:web   
69299 ttys000    0:13.16 webpack    
15421 ttys001    0:00.64 -zsh
 2587 ttys002    0:00.72 -zsh
20898 ttys003    0:01.20 -zsh
21234 ttys005    0:00.10 /bin/zsh -l
52494 ttys006    0:00.73 -zsh
68023 ttys006    1:12.57 ckb run
68024 ttys006    0:08.73 ckb miner
61381 ttys013    0:00.19 /bin/zsh -il
ckb-dev-chain $ lsof -nP -iTCP -sTCP:LISTEN | grep 68023
ckb       68023 tung   12u  IPv4 0x6929b9c90b8f15be      0t0  TCP *:8115 (LISTEN)
ckb       68023 tung  165u  IPv4 0xf0c8233a3a7a25ca      0t0  TCP 127.0.0.1:8114 (LISTEN)

Can I check the configuration of your local native node?

[tea2x]

Yes please check:

ckb.toml:

# Config generated by `ckb init --chain dev`

data_dir = "data"

[chain]
# Choose the kind of chains to run, possible values:
# - { file = "specs/dev.toml" }
# - { bundled = "specs/testnet.toml" }
# - { bundled = "specs/mainnet.toml" }
spec = { file = "specs/dev.toml" }

[logger]
filter = "info,ckb-script=debug"
color = true
log_to_file = true
log_to_stdout = true

[sentry]
# set to blank to disable sentry error collection
dsn = ""
# if you are willing to help us to improve,
# please leave a way to contact you when we have troubles to reproduce the errors.
# org_contact = ""

# # **Experimental** Monitor memory changes.
# [memory_tracker]
# # Seconds between checking the process, 0 is disable, default is 0.
# interval = 600

[db]
# The capacity of RocksDB cache, which caches uncompressed data blocks, indexes and filters, default is 256MB.
# Rocksdb will automatically create and use an 32MB internal cache for each column family by default if you set this value to 0.
# To turning off cache, you need to set this value to 0 and set `no_block_cache = true` in the options_file,
# however, we strongly discourage this setting, it may lead to severe performance degradation.
cache_size = 268435456

# Provide an options file to tune RocksDB for your workload and your system configuration.
# More details can be found in [the official tuning guide](https://github.com/facebook/rocksdb/wiki/RocksDB-Tuning-Guide).
options_file = "default.db-options"

[network]
listen_addresses = ["/ip4/0.0.0.0/tcp/8115"]
### Specify the public and routable network addresses
# public_addresses = []

# Node connects to nodes listed here to discovery other peers when there's no local stored peers.
# When chain.spec is changed, this usually should also be changed to the bootnodes in the new chain.
bootnodes = []

### Whitelist-only mode
# whitelist_only = false
### Whitelist peers connecting from the given IP addresses
# whitelist_peers = []
### Enable `SO_REUSEPORT` feature to reuse port on Linux, not supported on other OS yet
# reuse_port_on_linux = true

max_peers = 125
max_outbound_peers = 8
# 2 minutes
ping_interval_secs = 120
# 20 minutes
ping_timeout_secs = 1200
connect_outbound_interval_secs = 15
# If set to true, try to register upnp
upnp = false
# If set to true, network service will add discovered local address to peer store, it's helpful for private net development
discovery_local_address = true
# If set to true, random cleanup when there are too many inbound nodes
# Ensure that itself can continue to serve as a bootnode node
bootnode_mode = false

# Supported protocols list, only "Sync" and "Identify" are mandatory, others are optional
support_protocols = ["Ping", "Discovery", "Identify", "Feeler", "DisconnectMessage", "Sync", "Relay", "Time", "Alert", "LightClient", "Filter"]

# [network.sync.header_map]
# memory_limit = "256MB"

[rpc]
# By default RPC only binds to localhost, thus it only allows accessing from the same machine.
#
# Allowing arbitrary machines to access the JSON-RPC port is dangerous and strongly discouraged.
# Please strictly limit the access to only trusted machines.
listen_address = "127.0.0.1:8114"

# Default is 10MiB = 10 * 1024 * 1024
max_request_body_size = 10485760

# List of API modules: ["Net", "Pool", "Miner", "Chain", "Stats", "Subscription", "Experiment", "Debug", "Indexer"]
modules = ["Net", "Pool", "Miner", "Chain", "Stats", "Subscription", "Experiment", "Debug", "Indexer"]

# By default RPC only binds to HTTP service, you can bind it to TCP and WebSocket.
# tcp_listen_address = "127.0.0.1:18114"
# ws_listen_address = "127.0.0.1:28114"
reject_ill_transactions = true

# By default deprecated rpc methods are disabled.
enable_deprecated_rpc = false

[tx_pool]
max_tx_pool_size = 180_000_000 # 180mb
min_fee_rate = 1_000 # Here fee_rate are calculated directly using size in units of shannons/KB
# min_rbf_rate > min_fee_rate means RBF is enabled
min_rbf_rate = 1_500 # Here fee_rate are calculated directly using size in units of shannons/KB
max_tx_verify_cycles = 70_000_000
max_ancestors_count = 25

[store]
header_cache_size          = 4096
cell_data_cache_size       = 128
block_proposals_cache_size = 30
block_tx_hashes_cache_size = 30
block_uncles_cache_size    = 30

# [notifier]
# # Execute command when the new tip block changes, first arg is block hash.
# new_block_notify_script = "your_new_block_notify_script.sh"
# # Execute command when node received an network alert, first arg is alert message string.
# network_alert_notify_script = "your_network_alert_notify_script.sh"

# Set the lock script to protect mined CKB.
#
# CKB uses CS architecture for miner. Miner process (ckb miner) gets block
# template from the Node process (ckb run) via RPC. Thus the lock script is
# configured in ckb.toml instead of ckb-miner.toml, and the config takes effect
# after restarting Node process.
#
# The `code_hash` identifies different cryptography algorithm. Read the manual
# of the lock script provider about how to generate this config.
#
# CKB provides an secp256k1 implementation, it requires a hash on the
# compressed public key. The hash algorithm is blake2b, with personal
# "ckb-default-hash". The first 160 bits (20 bytes) are used as the only arg.
#
# You can use any tool you trust to generate a Bitcoin private key and public
# key pair, which can be used in CKB as well. CKB CLI provides the function for
# you to convert the public key into block assembler configuration parameters.
#
# Here is an example using ckb-cli to generate an account, this command will
# print the block assembler args(lock_arg) to screen:
#
#     ckb-cli account new
#
# If you already have a raw secp256k1 private key, you can get the lock_arg by:
#
#     ckb-cli util key-info --privkey-path <privkey-path>
#
# The command `ckb init` also accepts options to generate the block assembler
# directly. See `ckb init --help` for details.
#
#     ckb init <lock_arg>
#
# secp256k1_blake160_sighash_all example:
[block_assembler]
code_hash = "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"
args = "0x5fc646678a288fd445423c9a9ed358be26072f94"
hash_type = "type"
message = "0x"
# #
# # CKB will prepend the binary version to message, to identify the block miner client. (default true, false to disable it)
# use_binary_version_as_message_prefix = true
# #
# # Block assembler will notify new block template through http post to specified endpoints when update
# notify = ["http://127.0.0.1:8888"]
# # Or you may want use more flexible scripts, block template as arg.
# notify_scripts = ["{cmd} {blocktemplate}"]
#
# # CKB built-in indexer settings. Existing indexes can be cleaned up using the `ckb reset-data --indexer` subcommand.
# [indexer_v2]
# # Indexing the pending txs in the ckb tx-pool
# index_tx_pool = false
# # Customize block filtering rules to index only retained blocks
# block_filter = "block.header.number.to_uint() >= \"0x0\".to_uint()"
# # Customize cell filtering rules to index only retained cells
# cell_filter = "let script = output.type;script!=() && script.code_hash == \"0x00000000000000000000000000000000000000000000000000545950455f4944\""
# # The initial tip can be set higher than the current indexer tip as the starting height for indexing.
# init_tip_hash = "0x8fbd0ec887159d2814cee475911600e3589849670f5ee1ed9798b38fdeef4e44"

specs/dev.toml:

name = "ckb_dev"

[genesis]
version = 0
parent_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
timestamp = 0
compact_target = 0x20010000
uncles_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
nonce = "0x0"

[genesis.genesis_cell]
message = "1718420670284"

[genesis.genesis_cell.lock]
code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
args = "0x"
hash_type = "data"

# An array list paths to system cell files, which is absolute or relative to
# the directory containing this config file.
[[genesis.system_cells]]
file = { bundled = "specs/cells/secp256k1_blake160_sighash_all" }
create_type_id = true
capacity = 100_000_0000_0000
[[genesis.system_cells]]
file = { bundled = "specs/cells/dao" }
create_type_id = true
capacity = 16_000_0000_0000
[[genesis.system_cells]]
file = { bundled = "specs/cells/secp256k1_data" }
create_type_id = false
capacity = 1_048_617_0000_0000
[[genesis.system_cells]]
file = { bundled = "specs/cells/secp256k1_blake160_multisig_all" }
create_type_id = true
capacity = 100_000_0000_0000

[genesis.system_cells_lock]
code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
args = "0x"
hash_type = "data"

# Dep group cells
[[genesis.dep_groups]]
name = "secp256k1_blake160_sighash_all"
files = [
  { bundled = "specs/cells/secp256k1_data" },
  { bundled = "specs/cells/secp256k1_blake160_sighash_all" },
]
[[genesis.dep_groups]]
name = "secp256k1_blake160_multisig_all"
files = [
  { bundled = "specs/cells/secp256k1_data" },
  { bundled = "specs/cells/secp256k1_blake160_multisig_all" },
]

# For first 11 block
[genesis.bootstrap_lock]
code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
args = "0x"
hash_type = "type"

# Burn
[[genesis.issued_cells]]
capacity = 8_400_000_000_00000000
lock.code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
lock.args = "0x62e907b15cbf27d5425399ebf6f0fb50ebb88f18"
lock.hash_type = "data"

# issue for random generated private key: d00c06bfd800d27397002dca6fb0993d5ba6399b4238b2f29ee9deb97593d2bc
[[genesis.issued_cells]]
capacity = 20_000_000_000_00000000
lock.code_hash = "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"
lock.args = "0xc8328aabcd9b9e8e64fbc566c4385c3bdeb219d7"
lock.hash_type = "type"

# issue for random generated private key: 63d86723e08f0f813a36ce6aa123bb2289d90680ae1e99d4de8cdb334553f24d
[[genesis.issued_cells]]
capacity = 5_198_735_037_00000000
lock.code_hash = "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"
lock.args = "0x470dcdc5e44064909650113a274b3b36aecb6dc7"
lock.hash_type = "type"

[params]
initial_primary_epoch_reward = 1_917_808_21917808
secondary_epoch_reward = 613_698_63013698
max_block_cycles = 10_000_000_000
cellbase_maturity = 0
primary_epoch_reward_halving_interval = 8760
epoch_duration_target = 14400
genesis_epoch_length = 10
# For development and testing purposes only.
# Keep difficulty be permanent if the pow is Dummy. (default: false)
permanent_difficulty_in_dummy = true
starting_block_limiting_dao_withdrawing_lock = 0

[params.hardfork]
ckb2023 = 0


[pow]
func = "Dummy"

[Officeyutong]

Yes please check:

ckb.toml:

Config generated by ckb init --chain dev

data_dir = "data"

[chain]

Choose the kind of chains to run, possible values:

- { file = "specs/dev.toml" }

- { bundled = "specs/testnet.toml" }

- { bundled = "specs/mainnet.toml" }

spec = { file = "specs/dev.toml" }

[logger]
filter = "info,ckb-script=debug"
color = true
log_to_file = true
log_to_stdout = true

[sentry]

set to blank to disable sentry error collection

dsn = ""

if you are willing to help us to improve,

please leave a way to contact you when we have troubles to reproduce the errors.

org_contact = ""

# Experimental Monitor memory changes.

[memory_tracker]

# Seconds between checking the process, 0 is disable, default is 0.

interval = 600

[db]

The capacity of RocksDB cache, which caches uncompressed data blocks, indexes and filters, default is 256MB.

Rocksdb will automatically create and use an 32MB internal cache for each column family by default if you set this value to 0.

To turning off cache, you need to set this value to 0 and set no_block_cache = true in the options_file,

however, we strongly discourage this setting, it may lead to severe performance degradation.

cache_size = 268435456

Provide an options file to tune RocksDB for your workload and your system configuration.

More details can be found in the official tuning guide.

options_file = "default.db-options"

[network]
listen_addresses = ["/ip4/0.0.0.0/tcp/8115"]

Specify the public and routable network addresses

public_addresses = []

Node connects to nodes listed here to discovery other peers when there's no local stored peers.

When chain.spec is changed, this usually should also be changed to the bootnodes in the new chain.

bootnodes = []

Whitelist-only mode

whitelist_only = false

Whitelist peers connecting from the given IP addresses

whitelist_peers = []

Enable SO_REUSEPORT feature to reuse port on Linux, not supported on other OS yet

reuse_port_on_linux = true

max_peers = 125
max_outbound_peers = 8

2 minutes

ping_interval_secs = 120

20 minutes

ping_timeout_secs = 1200
connect_outbound_interval_secs = 15

If set to true, try to register upnp

upnp = false

If set to true, network service will add discovered local address to peer store, it's helpful for private net development

discovery_local_address = true

If set to true, random cleanup when there are too many inbound nodes

Ensure that itself can continue to serve as a bootnode node

bootnode_mode = false

Supported protocols list, only "Sync" and "Identify" are mandatory, others are optional

support_protocols = ["Ping", "Discovery", "Identify", "Feeler", "DisconnectMessage", "Sync", "Relay", "Time", "Alert", "LightClient", "Filter"]

[network.sync.header_map]

memory_limit = "256MB"

[rpc]

By default RPC only binds to localhost, thus it only allows accessing from the same machine.

Allowing arbitrary machines to access the JSON-RPC port is dangerous and strongly discouraged.

Please strictly limit the access to only trusted machines.

listen_address = "127.0.0.1:8114"

Default is 10MiB = 10 * 1024 * 1024

max_request_body_size = 10485760

List of API modules: ["Net", "Pool", "Miner", "Chain", "Stats", "Subscription", "Experiment", "Debug", "Indexer"]

modules = ["Net", "Pool", "Miner", "Chain", "Stats", "Subscription", "Experiment", "Debug", "Indexer"]

By default RPC only binds to HTTP service, you can bind it to TCP and WebSocket.

tcp_listen_address = "127.0.0.1:18114"

ws_listen_address = "127.0.0.1:28114"

reject_ill_transactions = true

By default deprecated rpc methods are disabled.

enable_deprecated_rpc = false

[tx_pool]
max_tx_pool_size = 180_000_000 # 180mb
min_fee_rate = 1_000 # Here fee_rate are calculated directly using size in units of shannons/KB

min_rbf_rate > min_fee_rate means RBF is enabled

min_rbf_rate = 1_500 # Here fee_rate are calculated directly using size in units of shannons/KB
max_tx_verify_cycles = 70_000_000
max_ancestors_count = 25

[store]
header_cache_size = 4096
cell_data_cache_size = 128
block_proposals_cache_size = 30
block_tx_hashes_cache_size = 30
block_uncles_cache_size = 30

[notifier]

# Execute command when the new tip block changes, first arg is block hash.

new_block_notify_script = "your_new_block_notify_script.sh"

# Execute command when node received an network alert, first arg is alert message string.

network_alert_notify_script = "your_network_alert_notify_script.sh"

Set the lock script to protect mined CKB.

CKB uses CS architecture for miner. Miner process (ckb miner) gets block

template from the Node process (ckb run) via RPC. Thus the lock script is

configured in ckb.toml instead of ckb-miner.toml, and the config takes effect

after restarting Node process.

The code_hash identifies different cryptography algorithm. Read the manual

of the lock script provider about how to generate this config.

CKB provides an secp256k1 implementation, it requires a hash on the

compressed public key. The hash algorithm is blake2b, with personal

"ckb-default-hash". The first 160 bits (20 bytes) are used as the only arg.

You can use any tool you trust to generate a Bitcoin private key and public

key pair, which can be used in CKB as well. CKB CLI provides the function for

you to convert the public key into block assembler configuration parameters.

Here is an example using ckb-cli to generate an account, this command will

print the block assembler args(lock_arg) to screen:

ckb-cli account new

If you already have a raw secp256k1 private key, you can get the lock_arg by:

ckb-cli util key-info --privkey-path

The command ckb init also accepts options to generate the block assembler

directly. See ckb init --help for details.

ckb init <lock_arg>

secp256k1_blake160_sighash_all example:

[block_assembler]
code_hash = "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"
args = "0x5fc646678a288fd445423c9a9ed358be26072f94"
hash_type = "type"
message = "0x"

# CKB will prepend the binary version to message, to identify the block miner client. (default true, false to disable it)

use_binary_version_as_message_prefix = true

# Block assembler will notify new block template through http post to specified endpoints when update

notify = ["http://127.0.0.1:8888"]

# Or you may want use more flexible scripts, block template as arg.

notify_scripts = ["{cmd} {blocktemplate}"]

# CKB built-in indexer settings. Existing indexes can be cleaned up using the ckb reset-data --indexer subcommand.

[indexer_v2]

# Indexing the pending txs in the ckb tx-pool

index_tx_pool = false

# Customize block filtering rules to index only retained blocks

block_filter = "block.header.number.to_uint() >= "0x0".to_uint()"

# Customize cell filtering rules to index only retained cells

cell_filter = "let script = output.type;script!=() && script.code_hash == "0x00000000000000000000000000000000000000000000000000545950455f4944""

# The initial tip can be set higher than the current indexer tip as the starting height for indexing.

init_tip_hash = "0x8fbd0ec887159d2814cee475911600e3589849670f5ee1ed9798b38fdeef4e44"

specs/dev.toml:

name = "ckb_dev"

[genesis]
version = 0
parent_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
timestamp = 0
compact_target = 0x20010000
uncles_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
nonce = "0x0"

[genesis.genesis_cell]
message = "1718420670284"

[genesis.genesis_cell.lock]
code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
args = "0x"
hash_type = "data"

An array list paths to system cell files, which is absolute or relative to

the directory containing this config file.

[[genesis.system_cells]]
file = { bundled = "specs/cells/secp256k1_blake160_sighash_all" }
create_type_id = true
capacity = 100_000_0000_0000
[[genesis.system_cells]]
file = { bundled = "specs/cells/dao" }
create_type_id = true
capacity = 16_000_0000_0000
[[genesis.system_cells]]
file = { bundled = "specs/cells/secp256k1_data" }
create_type_id = false
capacity = 1_048_617_0000_0000
[[genesis.system_cells]]
file = { bundled = "specs/cells/secp256k1_blake160_multisig_all" }
create_type_id = true
capacity = 100_000_0000_0000

[genesis.system_cells_lock]
code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
args = "0x"
hash_type = "data"

Dep group cells

[[genesis.dep_groups]]
name = "secp256k1_blake160_sighash_all"
files = [
{ bundled = "specs/cells/secp256k1_data" },
{ bundled = "specs/cells/secp256k1_blake160_sighash_all" },
]
[[genesis.dep_groups]]
name = "secp256k1_blake160_multisig_all"
files = [
{ bundled = "specs/cells/secp256k1_data" },
{ bundled = "specs/cells/secp256k1_blake160_multisig_all" },
]

For first 11 block

[genesis.bootstrap_lock]
code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
args = "0x"
hash_type = "type"

Burn

[[genesis.issued_cells]]
capacity = 8_400_000_000_00000000
lock.code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
lock.args = "0x62e907b15cbf27d5425399ebf6f0fb50ebb88f18"
lock.hash_type = "data"

issue for random generated private key: d00c06bfd800d27397002dca6fb0993d5ba6399b4238b2f29ee9deb97593d2bc

[[genesis.issued_cells]]
capacity = 20_000_000_000_00000000
lock.code_hash = "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"
lock.args = "0xc8328aabcd9b9e8e64fbc566c4385c3bdeb219d7"
lock.hash_type = "type"

issue for random generated private key: 63d86723e08f0f813a36ce6aa123bb2289d90680ae1e99d4de8cdb334553f24d

[[genesis.issued_cells]]
capacity = 5_198_735_037_00000000
lock.code_hash = "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"
lock.args = "0x470dcdc5e44064909650113a274b3b36aecb6dc7"
lock.hash_type = "type"

[params]
initial_primary_epoch_reward = 1_917_808_21917808
secondary_epoch_reward = 613_698_63013698
max_block_cycles = 10_000_000_000
cellbase_maturity = 0
primary_epoch_reward_halving_interval = 8760
epoch_duration_target = 14400
genesis_epoch_length = 10

For development and testing purposes only.

Keep difficulty be permanent if the pow is Dummy. (default: false)

permanent_difficulty_in_dummy = true
starting_block_limiting_dao_withdrawing_lock = 0

[params.hardfork]
ckb2023 = 0

[pow]
func = "Dummy"

Your native ckb client seems to be too old. In a newer version, there will be an option called reuse_tcp_with_ws to control whether to listen to websocket on the same port as TCP, as seen at https://github.com/nervosnetwork/ckb/blob/5f4eb98c5159a849c818f629e1498bab33a54a71/resource/ckb.toml#L88

[tea2x]

I'll try and let you know.
Thank you for your help!