Listening means the node has that service switched on.
Public opens it up on this machine, and that is the
part that decides whether anything outside can reach it. Both start
out on. Changing either one restarts the node.
Port
Service
On
Public
Choose which machines can reach the published ports. A new install
starts on 127.0.0.1, so switching a port on above does not expose
it until you pick 0.0.0.0 here as well. Changing this restarts the
node. Public IP: …
Node software
Checks kaspanet/rusty-kaspa for a newer
release and rebuilds the container. Your chain data is kept, so there
is no resync.
Not checked yet.
The node is built from the release archive upstream publishes, so it
runs a release rather than a branch. Picking an older one here is how
you go back to it.
Release notes
kaspad log
Stratum bridge
off
–pool hashrate
–active workers
–blocks found
–shares accepted
Network hashrate
–
Network difficulty
–
Bridge uptime
–
Block reward
–
Next reward
–
Projected earnings
–
Use my miners on keeps the box tracking what your
connected miners are reporting, so the earnings below follow them live.
Turn it off to type any hashrate and see what it would earn.
–per day
–1 month
–6 months
–12 months
Your share of the network
–
Network hashrate
–
Cost of the monthly cuts
–
This is what you would earn if difficulty and the reward stayed where they
are today, with the monthly drops taken into account. It is not a
prediction. Difficulty changes, and this says nothing about what Kaspa
is worth.
Workers
Worker
Hashrate
Difficulty
Shares
Blocks
Uptime
Recent blocks
Found
Worker
Reward
Blue score
Hash
Connect Your Miner
On your own network
Miners on the same network as this machine. Nothing to forward.
From outside
Miners elsewhere. Forward the stratum port on your router to
this machine first.
Username is kaspa:YOUR_WALLET_ADDRESS.WORKERNAME, password anything.
Find miners on your network
Looks for anything on your network that answers, and gives you a link
straight to it.
This machine can only work out its own network
(–) by itself. If your miner sits on a
different one behind your router, add it above. Anything works: a
range like 192.168.3.0/24, a shorthand like
192.168.3.*, or just the miner's address.
Private ranges are the same the world over, so the country you are
in makes no difference. What changes is the subnet your router
brand ships with, which is why the list names them. If you are not
sure, your router's own address is usually printed on a label
underneath it.
Stratum ports
Add a port for each group of miners. Giving slow and fast machines their
own port lets each start at a difficulty that suits it.
Port
Start difficulty
Publish
Apply
Port and difficulty changes need the bridge restarted to take effect.
Difficulty & tuning
KaChat-Indexer
Turns this node's chain data into the APIs KaChat clients talk to:
direct and group chats, broadcasts, KaPosts and mentions. It reads
the node you are already running, so nothing syncs twice.
off
Pipeline
–
–transactions, last hour
–transactions, last 5 minutes
–direct messages
–blocks processed
Node to ingest lag
–
Newest transaction
–
Newest content
–
Indexed last hour
–
Freshness comes from the transactions the node hands over. KaChat
content can lag behind that quite legitimately, because it only moves
when somebody actually posts.
Services
Waiting for the indexer.
Content indexed
Activity
Index KaPosts
Posts, replies, quotes, reposts, votes and follows. Turning this off
stops new ones being stored right away; the chain is untouched and
what you already have stays until you delete it.
KaPostsThe on-chain social feed.
Moderation by author
Remove deletes an author's rows once.
Block also adds them to your deny list, so the indexer
purges everything of theirs and stores nothing from them again. The
chain itself never changes, only this indexer's copy of it.
Personal mode
Curate this indexer with your own block list. When it is on, the
indexer watches the chain for blocks you publish and purges those
authors.
The indexer works out your pubkey from this and deny-lists anyone you
block on chain, restoring them if you unblock. That needs the KaChat
app to publish blocks on chain, so until then use the Block button
above to curate the list yourself.
Blocked authors
Everyone here is purged and stays un-indexed while listed. Remove
someone to let their content back in; re-indexing backfills what was
missed.
Author
Added
Indexing every author.
Recently indexed
When
Type
Author
Preview
Nothing yet.
Delete KaPosts data
This removes the indexer's stored copy only. The post is still on
chain, and a re-index would bring it back. It happens immediately
and cannot be undone from here.
Index broadcasts
Public channel chatter. Turning this off stops new broadcasts being
stored right away; rows you already have stay until you delete them.
BroadcastsEvery curated room the indexer ships.
Channels
–
Which rooms get stored, and how much of each is here. Changes apply
within about fifteen seconds and nothing restarts. Turning one off
does not delete what it already has, and adding one does not go back
and collect what it missed.
Not saved yet.
The cards are the channels this indexer knows about, which is a list
that ships inside it. A room the KaChat apps have started using may
not be here yet: rebuild the indexer under Updates to pick up its
newer list, or add the name above, which works either way.
Recent broadcasts
When
Channel
Sender
Message
Nothing yet.
Only the channels switched on above are indexed. Messages are kept
for 30 days and the preview shows the first 200 characters.
Delete broadcast data
These remove the indexer's stored copy only, and a re-index would
bring it back. They happen immediately and cannot be undone from
here. Switching a channel off stops new messages but leaves what is
already stored. Purging is how you clear that.
Index only your own chats
–
Keeps only your chats. Empty indexes everything.
Groups match on ids, set those under Group chats. Saving restarts the indexer.
Index chat and groupsCovers groups too.
Direct chats
–
Encrypted one to one messaging, live from your node.
Waiting for the chat indexer.
All indexer counters
Delete chat data
This wipes every one to one message, group, handshake and payment
the indexer holds. It only removes the stored copy. The messages are still
on chain, so a re-index would bring them back.
With personal mode on, the store then refills with only your own
data, which is how you turn a public store into a personal one.
Index only your own groups
–
A group message carries a blinded id that is specific to whoever sent
it, so one group has one id per member. List them and the indexer
keeps those groups. Leave it empty to keep all of them.
Your KaChat app knows these ids, since it already sends them when it
registers for notifications. Nothing here can work them out for you:
they come from the group keys, which this indexer never sees. Saving
restarts the chat indexer.
List every member's id for a group and you keep the whole conversation;
list only your own and you keep only what you sent. Your KaChat app
knows all of them, because reading a group means asking for each
member's id in turn. Whatever you send is kept either way.
Group chats
–
Group messaging and its control envelopes. The switch for it is on
the Chats tab, since one covers both.
Waiting for the chat indexer.
Move the whole store
Write this indexer's entire chat store to one file, or load one that
another indexer wrote. It copies byte for byte with no re-parsing,
which is the simplest way to move all your history between machines.
Backfill one address
Pull a wallet's direct message history out of the block explorer,
which is how you recover messages older than the node's pruning
window. Import your own address and your contacts' to rebuild both
sides of a conversation.
Source and updates
Tracks KaspaSilver/KaChat-Indexer and checks it for
commits newer than the one this image was built from. Indexed data is
kept, so there is no re-scan of the chain.
Not checked yet.
Rebuild is what to press after changing the branch or network; Update
is for staying where you are. The network must match the node's, or
the indexer reads a chain that is not there. A rebuild compiles from
Rust source and takes a while, which you can follow under All logs.
Post translation
KaChat apps ask this indexer to translate a KaPost into the
reader's language, and it is answered here, by a translation
engine running on this machine. Nothing is sent to Google or
DeepL and there is no API key: the engine is
LibreTranslate,
running offline beside the indexer. A post never changes, so
each translation is worked out once and served from a cache to
everybody who reads it afterwards.
Engine
–engine
–languages loaded
–translations cached
Nothing is installed yet. The engine is a container of its own, and
installing it does not start it.
Languages
Each language is a model the engine downloads once and then keeps in
memory for as long as it runs, so this list is a memory bill rather
than a preference. The eleven selected by default are the set the
indexer ships with, and fit the 4GB the container is allowed.
A running engine restarts to load a changed list, and is unavailable
for a few minutes while it does. A stopped one picks the list up
when you start it.
What the apps need
Nothing, beyond this. Translation is served from the indexer's own
address -- the same one already set in the app under Settings,
Connection Settings, KaPost Indexer -- so there is no second domain
to publish and no new setting for anybody to fill in. If the KaPosts
API is reachable, so is translation.
Endpoint
POST /translate on the KaPosts API
Languages offered
GET /translate/languages
Identity
None. It is the one endpoint that takes no pubkey, and post text is never logged.
Cache
Keyed on the post's transaction id and target language, kept permanently.
Published ports
Both APIs already work for anything running alongside them here. Only
publish one if you have apps connecting from another machine.
Publishing a port restarts the indexer.
KaChat Desktop
-
The KaChat client, served from this machine instead of a website.
Switch it on in the sidebar and open it in a browser. It is the same
app as the desktop build, so accounts and settings live in the
browser you open it with.
It talks to whichever node and indexer you point it at from inside
the app, so it does not wait for this node to finish syncing. If you
are running the indexer here too, point it at this machine.
Source and updates
Tracks KaspaSilver/KaChat-Desktop and checks it for
commits newer than the one this image was built from. Nothing is
stored server side, so an update never costs you anything.
Not checked yet.
Rebuild is what to press after changing the branch; Update is for
staying where you are. It reinstalls the app's dependencies, so give
it a few minutes and follow it under All logs.
Run NextcloudStarts Nextcloud with its database, cache and preview generator.
off
Open it
Sign in as the admin user with the password generated when it was
installed. Both are on the Settings tab, where you can also change
the password.
Nextcloud
Your own cloud for files, photos and video. It is where KaChat can
share media from and back chats up to, so none of it passes through
anyone else's servers. Video thumbnails and iPhone HEIC previews are
already set up for you.
It arrives with Contacts, Calendar,
Notes, Tasks and
Talk, installed the first time it starts.
It runs alongside the node with its own database and cache, and stays
off until you switch it on. Nothing else in this stack depends on it.
Talk's chat and one-to-one calls work as they are; group calls with
more than a few people want a TURN server, which this stack does not
run.
Access
If you give Nextcloud a domain, add it here too, separated by spaces
or commas. Nextcloud turns away requests for names it has not been
told about.
Apply
Changes here rebuild or restart Nextcloud.
Admin password
Generated when Nextcloud was installed. This is the password for the
admin user above, and the panel is the only place it is shown.
This changes it inside Nextcloud straight away and remembers the new
one here. Anyone already signed in stays signed in.
Source and updates
This is the official nextcloud:stable image with ffmpeg
added for video thumbnails — nothing here is a fork. A tag is not a
version: stable means a different image every few
weeks, so checking asks Docker Hub what it points at now and
compares that with what this one was built from. Your files and
database are on their own volumes, so a rebuild leaves them alone.
Not checked yet.
Updating pulls the current nextcloud:stable, rebuilds on
it and restarts the container. Nextcloud upgrades its own database
on first start afterwards, which can take a few minutes on a large
instance.
KaChat Bot
Watches this node for block rewards landing on your mining
address, and sends each one to your phone as a KaChat message.
off
The message is a Kaspa transaction you send to yourself, with the
notification encrypted into its payload. Nothing is posted to a
server and no push service is involved: KaChat reads it off the
chain and only your key can decrypt it.
Each notification costs about 0.002 KAS in fees, paid from the
wallet whose key you give it below. Nothing is ever sent
anywhere else.
What it is watching
Mining address
–
Notifies
–
Minimum reward
–
Wallet key
–
Network
–
Its own log is the record of what it has sent. It is under All
logs, as kaspa-node-kachat-bot.
Before it can work
The node needs its gRPC and wRPC Borsh listeners on, under
Kaspad, Ports. Neither has to be published.
You need to be mining to this node, with rewards paid to the
address below.
The sending wallet needs a little KAS for fees.
Set the bot up
Four things, and one of them is a wallet key. It is written to a
file only its owner can read, it is never shown again, and it never
goes into the panel's own settings file.
A block found now would send:
A minimum of zero notifies on every reward. Raising it filters out
the small ones.
KaChat Gift Service
Gives a new KaChat user their first 3 KAS, once, so they can
send a message before they have bought anything.
off
This is for people who run KaChat. Every
credential it needs belongs to a specific App Store and Play
Console listing — your own. It is not a public faucet, and
it cannot be pointed at somebody else's app.
Mode
–
Gift
–
Given today
–
Pool left
–
iPhone claims
–
Android claims
–
–
Limits
Apple and Google stop other people's scripts. These stop your own
mistakes: a loop that pays the same address forever is a bug
anyone can write, and the difference between noticing at 300 KAS
and at an empty wallet is a ceiling.
Which phone are you setting up?
Each store is configured separately and either can run without the
other. Both need credentials only their console will give you, so
have that tab open.
–
Service code
The service itself lives in KaspaSilver/KaChat-Gift-Service.
This rebuilds the container from it. Your keys are not in that
repository and are not touched by an update: they live in this
stack's own configuration directory.
The first build compiles nothing heavy, so it is quick. The
service is restarted at the end, which interrupts any claim in
flight.
Push ServiceMobile push notifications for the KaChat indexer — Android via Firebase, iPhone via Apple.
not set
This is only for people who run the KaChat mobile apps. Every value below
belongs to your own Firebase project (Android) and Apple developer account (iOS) — the
same accounts your App Store and Play Store listings are published under. If you just run a node
or indexer, leave this blank: the indexer works fine without it, it simply won't send push.
Keys are stored on this machine only, owner-readable (0600), and never leave the box.
The panel never shows a saved key back — an empty key box means “keep the one already saved”.
Android — Firebase Cloud Messaging
no key
iPhone — Apple Push Notification service
no key
Saving restarts the KaChat indexer to load the new settings (about two minutes). If the indexer is switched off, they apply the next time it starts.
Proxy and domains
Gives your node a proper web address instead of an IP and a port
number, with free HTTPS.
off
It takes ports 80 and 443 on this machine, so it stays off until you
ask for it. Leave it off if something else here already uses them.
Switch it on to add domains and certificates.
Public addresses
Everything here can have a web address of its own.
Set up walks the whole thing: a free DuckDNS name,
whatever the service needs switched on, the nginx configuration, and
an HTTPS certificate. One name serves one service.
The outside has to reach this machine somewhere.
By default that means forwarding ports 80 and 443 to it on your
router. Nothing outside your network can open these addresses
until something does.
If 80 and 443 already belong to something else, forward two other
outside ports to this machine instead and set them here. The check
below then tests those rather than 80 and 443. Certificates work
either way: a DuckDNS name is proved with a DNS record rather than
an inbound request, so it needs no open port at all. Addresses
then carry the port, as
https://yourname.duckdns.org:8443.
what the internet dials
what nginx binds here, and what a forwarding rule points at
Usually the same numbers on both rows. They differ when a router
maps one to the other, and when it cannot, set this row to match
the rule. Changing what nginx binds restarts the proxy.
Asks check-host.net to try connecting to your address. It sees your public IP.
Service
Status
Public address
A service that is switched off can still be given an address: nginx
serves it either way and it starts answering the moment the service
does.
–
Proxy hosts
Every name this machine answers for, and what it forwards each one
to. The ones Public addresses set up appear here too — this is the
same list, with the details it does not ask about.
Address
Forwards to
HTTPS
Another machine can sit behind this one. Only one
machine on your network can hold port 443, but it does not have to
be the machine running the service. Choose
Custom host:port and give this proxy the other
machine's address on your network, and it will forward that name
to it — certificate and all, handled here.
So a second machine running something else needs no proxy, no
certificate and no forwarded port of its own. It serves plain http
on your network, this machine terminates HTTPS in front of it, and
each name goes where it belongs.
KasSigner
An air-gapped device that holds your keys offline and signs by
QR code. Switching this on downloads the firmware and checks
every image against the hash the project publishes.
off
Which device do you have?
Plug it in
Writing firmware
working
Verify the firmware
Checks every firmware file on this machine against the SHA-256
hashes the release notes publish, and shows the whole comparison
rather than a verdict. The hashes are fetched from GitHub each time
this runs, not read back from this machine: a file and a hash
written here at the same moment agree with each other by
construction, which would prove nothing.
not checked yet
This establishes that the bytes here are the bytes the project
published. It says nothing about whether the firmware is good, and
no hash can. The same release publishes hashes for unsigned images
so that a build from source can be reproduced and compared, and
those are printed at the end of the log for anyone doing it.
Firmware
Tracks InKasWeRust/KasSigner. Each release publishes a
SHA-256 for every image, and nothing is written to a device unless
the download matches it.
Not checked yet.
This only refreshes the copy held here. Putting a new version on a
device is a flash, which you start from Setup with the board plugged
in.
Admin password
–
This panel drives the Docker daemon, which is root on this machine.
A password is what makes it safe to reach from anywhere other than
this computer, and it is required before the panel itself can go on
a domain. Saving restarts the panel, which takes a few seconds; the
node, the proxy and every app keep running throughout.
Panel address
–
Worth moving if you want the reverse proxy on this port instead:
8080 is the usual second choice for plain http, and only one thing
can hold it. The panel restarts and this page follows it to the new
address; nothing else is affected.
Update the control panel
This updates the panel itself, not the node. It downloads the latest
files, rebuilds the panel image and restarts it. Your settings,
certificates and chain data are untouched, and the node keeps
running throughout.
Installed
–
Install directory
–
Checked against GitHub when you ask, never on its own.
The panel goes offline for a minute or two while it rebuilds. This
page will say so and come back on its own.
Remove everything
Deletes every container, image, volume, network and file this stack
created, including the node, its chain data and this panel. Docker
itself is left installed, along with anything else you run on it.
Chain data goes with it, so a fresh install re-syncs from
scratch. That takes hours.
KaChat and Nextcloud data goes too, including anything stored in
Nextcloud.
Base images shared with your other projects are skipped
automatically rather than pulled out from under them.
One small helper image (docker:cli) is fetched to do
the removing, and is the one thing left behind, because it cannot
delete the image it is running from. Clear it with
docker rmi docker:cli.
There is no undo, and no cancelling once it starts. The log
appears on screen and runs until this panel is removed.
Get in touch
Questions, bugs, or something in here behaving oddly. Email gets read;
the rest are the same handle everywhere, which makes it easy to check
you are talking to the right person.
Two things answer most of it, and both save a round trip.
All logs shows every container live. Whatever went
wrong usually says so there, and the text is worth pasting in.
The panel version is at the bottom of the sidebar,
and each app's Updates tab says which commit it was built from.
This panel is packaging. Anything about the node itself belongs
upstream with kaspanet/rusty-kaspa.
Donate
This panel is free and stays free. If it saved you an evening, a few
KAS is a kind way to say so. Entirely optional, and nothing in here works
differently either way.