Sidechain slot 9 · Skydoge testnet
HIVEMIND▶ Git Init
Prediction markets on Skydoge. Truthcoin, in C++, as a sidechain.
This site is dedicated to Pol Sports — and a special shout out goes to CRYPTAXE, who wrote the Hivemind C++ that everything here runs on.
1:12 — Run against the record
- MissionGoldenEye 007 · Streets · Agent · record 1:12 (Ryan Lockwood) = 72 s
- Clock72.000 s run on the operative’s own clock · record pace · no comms · player telemetry never read
- Target1:12 · move 1, ply 12 · ratio 1 : 12
- Lattice8 files × 14 ranks = 112 cells · lock on cell 112 (h14)
- Block 6003 voters · 2 concur · 1 dissents
- Reputation0.33333333 each → 0.30000000 / 0.35000000 / 0.35000000
- Splitslattice 0.60 · count 3.36 · lock 0.70 · resolve 1.34 · run 6.00 s
- Settlement3.00 coins paid out at block 528
- VerdictRun complete · ♔ mate in 112 · truth settled by vote
What you are looking at
The record is real: 1:12 — seventy-two seconds — is the fastest known run of the Streets level in GoldenEye 007 on Agent. This panel runs the same seventy-two seconds, and spends them settling a question instead of clearing a level.
That is the whole idea behind Hivemind. Nobody is asked to trust a referee. A question is put to people who have something at stake, they answer independently, and the answer the weight of them agrees on becomes the settled one. Here three voters answered, two agreed and one did not.
Disagreeing with the outcome is not punished by a rule — it simply costs standing. Each voter began with an equal share and the dissenter ended up holding a little less of it, so next time their answer carries less weight. Truth is not declared; it is paid for, round after round.
The settlement line at the bottom is from an actual round on our test network — the coins moved, and the lattice above is the board that round was decided on: eight files by fourteen ranks, one hundred and twelve cells, the last of them the one that mattered.
an easter egg — or type bee anywhere, or add #bee to the URL
Warning
TESTNET ONLY. This runs on the Skydoge testnet. Coins here have no value, the chain can be reset without notice, and the software is experimental. Do not put anything you care about into it.
Hivemind is Paul Sztorc's Truthcoin design: a blockchain whose job is to decide what actually happened, and to let people trade on it beforehand. Skydoge carries it as a sidechain, so the markets settle against a chain secured by Skydoge's own proof of work rather than by a company.
01What it does
BRANCHES
A branch is a rulebook: how long voting lasts, what listing costs, how much disagreement is tolerated before a result is thrown out.
DECISIONS
A decision is a question with an answer the world will eventually know. Voters are paid to report it honestly and penalised for drifting from everyone else.
MARKETS
A market lets you buy and sell shares in those answers. The price is the crowd's estimate, and it moves as people put money behind opinions.
SETTLEMENT
When the question resolves, shares in the correct answer pay out and the rest expire. No arbiter, no appeal to a company.
02Downloads
Linux x86-64. Built against glibc 2.14, so it runs on anything from about
2011 onward. Qt is linked statically, so hivemind-qt is a single
file with no Qt install needed.
version20261002n
20261002n — consensus now validates a market
before it indexes it. Until this build, every OP_MARKET output
in a block was indexed as supplied and the market layer trusted that index as
though consensus had checked it. Two rules close the worst of that. A branch or
market whose parameters cannot be coherent — a zero voting period, ballot
and unseal phases that do not fit inside one cycle, a zero LMSR beta, more
decisions than the state count can hold — makes the block invalid
(market-params-incoherent). A branch outcome carried in a coinbase
must carry that block's own height (market-outcome-height-mismatch),
so a miner can no longer post-date an outcome and steer the reputation that the
next round inherits. A market is capped at sixteen decisions, because at
thirty-two the state count wraps to zero.
These two rules activate at block height 29000. Below that height this build accepts and rejects exactly what 20261002e does, so upgrading early costs nothing and splits nothing. From height 29000 a node still running an older build will accept blocks that this one refuses, and it will follow a chain that upgraded nodes have abandoned. Upgrade before then.
Everything 20261002e brought is still here: PIE, full RELRO, FORTIFY_SOURCE and stack protection; a revealed ballot only counts if it opens the seal published for it; a market settles bounded by the money that actually entered it.
Coming from 20261002e: just replace the binaries. Same chain, same data directory, no reset. Stop the node, swap the three files, start it again.
hivemind-cli stop # or quit the wallet # replace hivemindd, hivemind-cli and hivemind-qt with the ones below # then start it again - nothing else to do
Coming from anything older than 20261002e: you must delete your chain data first. The chain was reset on 2 October 2026 and settlement rules changed, so blocks after height 495 on the old chain are no longer valid. A node that only swaps the binary keeps the old branch and sits on it.
hivemind-cli stop # or quit the wallet cd ~/.hivemind rm -rf blocks chainstate market sidechain peers.dat mempool.dat # keep wallet.dat and hivemind.conf - your coins and settings are in those
Then start the new build. It will sync from height 0. If you skip this you
will see market payout missing in the log and the node will stop
following the chain.
If an older build refuses to follow the chain — rejecting blocks and not catching up — it is out of date. Settlement has changed; use the build above.
The archive holds three files. Verify them after unpacking with
sha256sum -c SHA256SUMS:
1f34b7c8a97efbb20f40ef4e7cf7070321130c50b6b91ad9c63f0ba1c226bf5c hivemindd a8f7849d66894ff00abc12651d62f8cad397769672fc92ed1d887482b7d4af29 hivemind-cli 030a2e068268da17fbcd14934d42308a07de1ffaf6b2717588e483542ee17498 hivemind-qt
03Why C++ and not Rust
There is a Rust implementation of Hivemind, truthcoin-dc, and in
places it is the better-designed one. We built on the C++ tree anyway, and the
reason is the dependency graph. That gap is wider than a package count makes it
look.
truthcoin-dc 866 packages, 10 pulled straight from git
including the enforcer library that decides
deposits and withdrawals
this C++ tree 33 depends packages (about half exist only for
the Qt GUI on X11) + 4 vendored libraries
Both pin by hash — Cargo.lock carries a sha256 per crate, and
depends/ fetches tarballs by sha256 — so pinning is not the
difference. What the raw count understates is this: in Cargo a dependency does
not merely ship code into your binary, it runs code on the machine that builds
it. Build scripts (build.rs) and procedural macros execute at
compile time with the privileges of whoever typed the build command. So the question
is not only whether any of 866 packages contains a backdoor; it is whether any of 866
publishing identities can run a program on the machine that compiles the binary that
holds other people's money. The ecosystem has tools for precisely this —
cargo vet, cargo crev, vendoring — and they work, but
somebody has to run them, and on this project nobody had.
Then the ten git dependencies, which are the part that actually decided it. One of them is the enforcer library that validates deposits and withdrawals — the code path that moves money across the peg. A lock file pins a git dependency to a commit, but a git remote is not an immutable published artifact: history can be rewritten, tags move, and a repository can stop existing. For a consensus component that is a worse place to fetch from than a registry, and a far worse one than a tarball with a known hash sitting in your own tree.
The C++ side deserves the same scrutiny, so: building those 33 packages also runs
their configure and make. Build-time code execution is not
unique to Cargo. The difference is an order of magnitude in how many parties you are
trusting, and that the set is short enough to name — boost, leveldb, secp256k1,
Qt — instead of a long tail nobody has read.
The obvious objection is that this tree's copies are old: they are 2018-era, and leveldb, secp256k1 and the Bitcoin Core 0.16-era base have had upstream fixes since that it does not carry. That is true, and it is a migration with a known shape rather than a standing obligation.
That asymmetry is the whole argument. Stale pinned tarballs are a migration you can schedule, carry out once, and then be finished with; and until you do, they do not change underneath you. A graph of 866 packages with ten git remotes is not a task you complete — it is a standing obligation that moves every time anyone updates it, and it has to be re-audited each time.
There is one place where Rust's default is stricter, and it is worth
naming exactly, because it is almost always misattributed. Rust bounds-checks array and
vector access by default; an out-of-range read in C++ can return a plausible wrong value
and carry on. That is the bounds check — not the borrow checker. C++ has
the same protection, as something you switch on: .at(),
-D_GLIBCXX_ASSERTIONS, sanitizers in CI. So the real question is not which
language ships it by default, it is whether the people building the thing turned it on.
We turn it on, and we build the same tree twice in a sealed container and compare the
bytes, which is a check neither language gives you for free.
What C++ gives back is the part that decided it. This is a chain that settles money on the strength of a computed number, and the property we need is that the same inputs give the same answer on every machine, this year and in ten years, on a toolchain somebody can audit end to end. That is an old requirement, and it is met in the places where a wrong answer is not survivable: flight control, engine management, avionics under DO-178C, with qualified compilers and a standard that does not move underneath you. C++ has been trusted in that seat for decades. Rust is earning the same seat now — genuinely, and the qualification work below is real — but it is arriving, not arrived. We picked the language that already flies. That is where the name comes from: SkyDoge.
There is a second half to that, and it points back at the dependency count.
Rust's memory-safety guarantee covers safe Rust only. The
unsafe keyword opts out of exactly the checks that would have caught our
two indexing bugs, and buffer overflows in Rust are not hypothetical: the RustSec
advisory database carries them against real crates, including widely used ones such
as smallvec and pyo3. Researchers who scanned the registry
for the RUDRA paper found 264 previously unknown memory-safety bugs, which became 76
CVEs and 112 RustSec advisories — about half of every
memory-safety bug reported to RustSec since 2016. Their finding on cause is the part
worth sitting with: the buffer overflows looked like C and C++ buffer overflows,
logic errors and raw pointer arithmetic, because inside an unsafe block
that is what you are writing.
So the 866 crates are not only a supply-chain surface. Every one of them that
reaches for unsafe is memory-safety surface the compiler is not checking
on your behalf, and you have inherited it. The guarantee is strong for code you write
and silent about code you import.
The other half of the picture is the class of bug no language prevents: wrong
values rather than invalid memory — a quantity scaled by the wrong factor, a
decimal consumed as an integer, a result computed and then discarded. Rust does not
address those, and in one respect it is pointedly unhelpful here:
in a release build, integer overflow wraps silently, because
overflow-checks defaults to off outside debug builds. That is defined
behaviour rather than undefined, which makes it safe and still wrong — and a
node that computes a wrong number does not crash, it disagrees, which on a consensus
chain is the more expensive outcome. It also means a debug node and a release node can
part company on the same block.
A fair question follows: this tree descends from a 2018-era Bitcoin Core, so what about everything found in Core since? Worth separating two things there. The Skydoge mainchain has had substantial review — a multi-model audit across its tree, and a separate consensus audit, both of which went looking for known Core issues by name. This sidechain is newer and has not yet had the same treatment; that work is under way. It will be written up properly when the source is published, because a security claim is worth only as much as the code someone can check it against, and until the tree is out there is nothing to check.
One last axis, and it is the one people reach for: C++ flies. It is in certified avionics at DO-178C Design Assurance Level A — the level used where a failure is catastrophic — and it has been for decades, with qualified compilers and restricted coding standards like MISRA C++ and AUTOSAR C++14 built around it. Rust is only now arriving there. The Ferrocene toolchain is TUV SUD-qualified for ISO 26262 ASIL D, IEC 61508 SIL 3 and IEC 62304 Class C, and supports qualification toward DO-178C DAL C, not DAL A; and as of late 2025 only a certified subset of Rust's own core library exists, at SIL 2. The gap is closing, and it is still a real gap.
But look at why that gap exists, because it is the same argument again rather than a new one. Certification is an evidence regime: you must account for every line you ship and qualify the tools that produced it. That is not a language property, it is a provenance property — and it is structurally impossible with a graph of 866 packages, because you would have to qualify all of them. The standards are, in effect, a formal version of the question this whole section asks: how many parties do you have to trust, and can you name them?
And the part that cuts at us, so it had better be said here. The C++ that flies is a heavily restricted subset — typically no dynamic allocation, no exceptions, often no templates, all of it traced and coverage-analysed to MC/DC. That is not the C++ in this tree. This is Bitcoin Core-derived code: heap allocation everywhere, exceptions, templates, and a 2018-era dependency set. "C++ runs on planes" is true, and it is not a claim about this software. Nothing here is certified and nothing here has been near a qualification process. The right conclusion is not that our language is the safe one. It is that on the axis which actually decides these things — can you account for what you ship — a short, nameable dependency set beats a large one, and that is the whole reason we are on this tree.
So: a smaller and nameable set of parties to trust at build time, a peg whose validation does not come from a git checkout, and an ageing base that can be brought forward as ordinary engineering. That is the trade, and for consensus code that moves money it is the right way round.
04What works, and what does not
Stated plainly, because the useful thing for a tester is knowing where the edge is.
Status. The full loop runs on the Skydoge testnet: coins move onto the sidechain, blocks advance under blind merged mining, markets resolve by vote, and coins move back out. It is early software, and this sidechain has not been through the review the Skydoge mainchain has.
The round trip is proven. Coins were deposited from the Skydoge chain, traded on the sidechain, and withdrawn back. The withdrawal was bundled with nine others, the bundle was accepted by the Skydoge chain, miners voted it up over 131 blocks, and it paid out — ten separate destinations funded in one mainchain transaction, with the remainder returned to the sidechain's own balance. That is the whole drivechain loop working, not a simulation of it.
Reputation was measured on chain, not just implemented. The lab above explains the mechanism; this is what the chain actually recorded. Three voters, one question, two agreeing and one dissenting, at two consecutive voting boundaries:
boundary 600 old 0.33333333 0.33333333 0.33333333
this 0.00000000 0.50000000 0.50000000
new 0.29999999 0.34999999 0.34999999
boundary 608 old 0.29999999 0.34999999 0.34999999 ← carried forward
this 0.00000000 0.50000000 0.50000000
new 0.26999999 0.36499999 0.36499999
Two things are visible there. The second round's starting reputations are exactly the first round's results, so reputation genuinely carries from one round to the next rather than resetting. And every new value is 0.9 × old + 0.1 × this round, the smoothing formula, to the last digit — which is the check worth doing, because a number that does not satisfy the formula did not come from it.
The decay is worth seeing plainly too: the dissenter goes 0.3333 → 0.3000 → 0.2700, losing a tenth each round. It approaches zero and never arrives, which is the point of the smoothing — being outvoted costs you influence steadily rather than wiping you out in one round. There is no cliff and no need for a recovery mechanism.
Shares now cost what they quote. Until this build the purchase price was calculated and then discarded — five shares quoted at 4.99 coins cost only the 0.01 fee. Now buying three shares quoted at 3.00 costs 3.01, the price plus the fee. The coins leave your balance when you buy, and a settled market pays out to the holders of the winning side.
Votes now resolve into an answer. The consensus algorithm — a weighted principal-component method that scores voters against each other rather than simply counting them — was present in the code all along but was being fed nothing. Votes were written to disk and never read back, every voter was recorded under the same empty identity, and three of the algorithm's parameters were passed at the wrong scale, which put every result in the “inconclusive” band. With those fixed, two voters agreeing on a question now produce a decided answer rather than a tie, and the reputation and certainty figures come out sane.
Settlement pays, and here is the evidence. When a market matures, each trader's payout is computed and paid, and the rule that validates the block checks that amount independently before accepting it. On 1 October 2026,
at sidechain height 528, market
15020ea5…d96fb5 settled: a position of three shares,
bought for 2.36 coins, paid out 3.00 coins to the buyer's
own address. A second node validated the block and accepted it, and the
coins are spendable. The node's own log, with the payout computed and then independently re-checked before the block was accepted:
market settled... settles 300000000 to 0b9aace0... (net 300000000 shares, payout 1.000000)
ConnectBlock: market settlement at height 528 pays 300000000 across 1 output(s)300000000 is 3.00 coins expressed in satoshi. The shares cost 2.36 at an LMSR price of 0.787 each and settled at 1.00, so the holder cleared 0.63 — which is the whole point of a prediction market. An earlier settlement at height 496 paid out correctly but on a position recorded at a much smaller scale, so the amount was tiny; the build above is the one to use. The settlement rule itself is what was missing for years, and it is in.
05The price engine, live
Every Hivemind market is priced by an automated market maker: the
logarithmic market scoring rule, LMSR. There is no order book and no
counterparty to wait for — a formula quotes a price for every share, and
each purchase nudges it. The instrument below runs the textbook LMSR for a
YES/NO question entirely in your browser. It is not connected to the chain and
sends nothing anywhere; the authoritative numbers for a real market always come
from listtrades.
How much money it takes to move the price. Also the maker's worst-case loss, B·ln 2.
Fresh market. Nobody has bought anything, so the maker quotes 50.0% for YES. Buy something and watch the price move.
The formula behind the curve
Cost function: C(q) = B · ln( eqYES/B + eqNO/B ).
The price of YES is its share of that sum: pYES = eqYES/B / ( eqYES/B + eqNO/B ).
A trade costs C(after) − C(before), so buying a lot at once is priced by the whole stretch of the curve you cross, not the price where you started.
“Paid into market” is C(q) − C(0), and C(0) = B·ln 2 is the most the maker can ever lose. Shares and coins here are abstract units.
06The vote engine, live
When a decision matures, nobody counts hands. Every voter's
ballot goes into a matrix, the matrix is decomposed (a weighted principal
component, found by singular value decomposition), and each voter is scored
by how well they sit with the mainstream of that round. Agreeing earns
reputation; dissenting loses it; reputation weights the next round — a rating, in the chess sense, that climbs while you sit with the field and decays while you play against it. This is
the mechanism that makes it expensive to lie to a Truthcoin oracle. The
instrument below is a port of the node's own consensus routine
(tc_vote_proc in src/linalg/src/tc_mat.c), checked
against the C library on twelve vote matrices to twelve significant digits.
Click any cell to change a vote; the result recomputes at once.
| OUTCOME |
| CERTAINTYCERT. |
Scored like a game: 1-0 YES · 0-1 NO · ½-½ tie, nobody is paid. An N/A is the unfinished game, *: the engine fills it with that decision's preliminary mean and it counts for nobody.
How fast reputation moves: new = (1−α)·old + α·this round.
A weighted mean inside 0.5 ± tol/2 is a tie and resolves to 0.5.
What the engine actually computes
Each round, with the vote matrix M (voters × decisions) and the old reputation vector w: missing votes are filled with that decision's preliminary w-weighted mean; the matrix is centred by its weighted column means and its weighted covariance C = Σ wk xkxkT / (1 − Σ wk2) is formed; an SVD of C (Householder bidiagonalisation, Wilkinson-shift QR) gives the first loading; each voter's score is their centred row projected on it. Two candidate reputation vectors are built from the scores (shifted so the minimum is zero, and the mirror image), excess above the weighted median is halved, and the candidate closer to a compliance measure — distance from the preliminary outcomes, weighted by one over each decision's loading — is kept and normalised to sum to one. New reputation is (1−α)·old + α·this. Each decision's outcome is the new-reputation-weighted mean of its column; above 0.5 + tol/2 is YES, below 0.5 − tol/2 is NO, between is a tie at 0.5. Certainty is the reputation held by voters who agree with the final answer. Only + − × ÷ |x| √x are used, which is what lets every node arrive at the same bits.
Honest limits. Binary decisions only here; the node also supports scaled ones (weighted medians). The reputation carried between rounds by NEXT ROUND is the Truthcoin design, and the node does the same: each round starts from the reputations the previous round produced, as the on-chain table in section 04 shows. α 0.1 and tol 0.2 are the values the slot-9 branch was created with. One floating-point quirk is real and reproduced here: with six voters at reputation exactly 1/6, a unanimous round does not hit the "perfect consensus" branch (6 × 1/6 is not 1 in binary), so everyone scores zero for that round; with eight at 1/8 it does, which is why this lab seats eight.
- branch
- Sprint · block 600
- tau
- 8 blk · ballot 2 · unseal 2
- matrix
- 3 voters × 1 decision
- V0 → D0
- 0 · NO
- V1 → D0
- 1 · YES
- V2 → D0
- 1 · YES
| voter | vote D0 | oldRep | thisRep | smoothedRep | change |
|---|---|---|---|---|---|
| V0 | 0 | 0.33333333 | 0.00000000 | 0.29999999 | −10 % |
| V1 | 1 | 0.33333333 | 0.50000000 | 0.34999999 | +5 % |
| V2 | 1 | 0.33333333 | 0.50000000 | 0.34999999 | +5 % |
| outcome D0 = 1.0 (YES) · market settled block 528: 3 shares, cost 2.36, paid 3.00 (+0.64) at settlement · mainchain slot 9 = this sidechain, slot 69 = Pol Sports · node prints 0.29999999 for 0.9·0.33333333 + 0.1·0 (float) | |||||
07How it attaches to Skydoge
It is a drivechain sidechain in slot 9. Coins move onto it by a deposit on the Skydoge chain, and its blocks are carried by Skydoge miners through blind merged mining — miners commit to sidechain blocks without having to run or understand the sidechain themselves.
Illustration of the rhythm described below: at most one sidechain block per mainchain block, in practice roughly every other.
- SIDECHAIN SLOT
- 9
- MAINCHAIN
- Skydoge testnet
- BASED ON
- LayerTwo Labs' Hivemind, itself a Bitcoin Core fork
- BLOCK RATE
- One sidechain block per mainchain block at most. In practice roughly every other block, because a bid is only mineable in the block immediately after the tip it was made for.
08Before you start: you need a Skydoge node too
Warning
Hivemind talks to a Skydoge node over RPC at 127.0.0.1, and that address is hardcoded. The Skydoge testnet node must run on the same machine. A remote one cannot be used.
It also cannot use cookie authentication. Hivemind builds
its mainchain credentials from the rpcuser and
rpcpassword in its own config, so your Skydoge testnet
node must have those set to the same values.
In your Skydoge config, under a testnet section so your mainnet node is untouched:
[test] server=1 rpcuser=pick-something rpcpassword=pick-something-long addnode=skydoge.network:18441 addnode=45.86.162.81:18441
Those two addnode lines are not optional. The Skydoge testnet ships with no DNS seeds and an empty fixed-seed list, so a fresh node has no way to discover the network — it will sit at zero peers forever without them. The two addresses are separate machines; keep both, so one being busy does not leave you stranded.
Then ~/.hivemind/hivemind.conf:
server=1 rpcuser=pick-something rpcpassword=pick-something-long mainchainrpcport=18332
Start the Skydoge testnet node first, let it sync, then:
./hivemindd -datadir=$HOME/.hivemind -daemon ./hivemind-cli -datadir=$HOME/.hivemind getblockcount
A seed node is compiled in, so it finds the network on its own. There is no
hivemind testnet — the slot-9 chain runs as hivemind's main
network, with the upstream seed list removed.
09Getting coins
There is no faucet. CPU-mine the Skydoge testnet — difficulty is low enough that a laptop finds blocks — then deposit into slot 9.
Warning · funds at risk
Use a legacy address for the deposit, or you will lose the
coins. getnewaddress returns a P2SH address by default.
A deposit to one of those produces an output your wallet reports as yours and
counts in getbalance, but which can never be spent —
silently, with no error, and the balance still looks right.
# a legacy address - note the empty label and the "legacy" type
ADDR=$(./hivemind-cli -datadir=$HOME/.hivemind getnewaddress "" legacy)
# the deposit string is s<slot>_<address>_<first 6 hex of sha256 of
# everything up to and including the trailing underscore>
PRE="s9_${ADDR}_"
# sha256sum is GNU coreutils only: macOS has shasum, BSD has sha256. With a
# missing tool SUM is empty and the deposit is rejected (see below).
sha256_6() {
if command -v sha256sum >/dev/null 2>&1; then sha256sum | cut -c1-6
elif command -v shasum >/dev/null 2>&1; then shasum -a 256 | cut -c1-6
else sha256 | tr -d '\n' | tail -c 64 | cut -c1-6; fi
}
SUM=$(printf '%s' "$PRE" | sha256_6)
skydoge-cli -testnet createsidechaindeposit 9 "${PRE}${SUM}" 1 0.001
Two errors you may meet, and what each means. error code: -5
… Invalid sidechain deposit address - failed to parse means the
checksum is wrong or missing — usually because sha256sum
was not on your machine and SUM came out empty, which the helper
above avoids. error code: -1 … Could not collect enough coins to
cover deposit + fee! means the address was fine but the Skydoge
testnet wallet has no coins yet: get some on the mainchain first (previous
section), then deposit.
The deposit is credited in a sidechain coinbase, so give it a few sidechain blocks before it appears.
From the wallet instead of a shell
The Deposit tab will not build the address for you
In the Skydoge wallet's sidechain Deposit tab you must paste the
whole deposit string, s9_<address>_<6 hex>
— not a plain sidechain address. The field's tooltip says “the
Skydoge address to send the payment to” and its placeholder shows
S0xxxxxxxx, both of which are misleading: there is no slot 0 here
and the checksum is required. Paste a bare address and you get
“Invalid sidechain deposit address! Check the address you have
entered and try again”, which does not tell you what is actually
missing. Build the string first.
Two ways to do it without a shell. Either run the deposit from the wallet's own console — in the Skydoge wallet open Window → Console (or Help → Debug window → Console) and type:
createsidechaindeposit 9 "s9_YOUR_LEGACY_ADDRESS_abc123" 1 0.001
… or paste a legacy Hivemind address below and this page will assemble the string for you. Nothing is sent anywhere — the hash is computed in your browser.
Deposit string — paste this into the Deposit tab, or into the console command above:
paste an address above
10Making a market
Two gotchas
Two gotchas worth knowing before you fight them. Decisions and markets need
a legacy address, same as deposits. And createmarket's
liquidity, fee and commission arguments are integers in
satoshi, despite the help text calling them numeric — passing
0.01 fails with a misleading "JSON integer out of range".
createtrade is the other way round — its share count and
price are ordinary decimals, so buy 3 1 1 buys
three shares. Before 1 October it took satoshi there as well, so older notes
elsewhere may show a very different looking command.
The example below is a chess game, because a game is the cleanest shape a
market can have: a named event, a settlement date, and exactly three results
— 1-0, 0-1, ½-½. A
binary decision has to collapse those three to YES or NO in its own
text, before anyone trades; here a draw settles NO, and the question
says so. Leave that unsaid and the voters, not the market, decide what a
draw meant.
CLI="./hivemind-cli -datadir=$HOME/.hivemind"
BRANCH=$($CLI listbranches | grep -m1 branchid | cut -d'"' -f4)
ADDR=$($CLI getnewaddress "" legacy)
$CLI createdecision "$ADDR" "$BRANCH" \
"Does White win board 1 of the club final, 15 Nov 2026? A draw is NO" \
1000 false false
# take the decisionid from the reply, wait for a block, then:
$CLI createmarket "$ADDR" "$DECISIONID" 100000000 1000000 1000000 \
"White wins board 1" "Settles YES on 1-0. A draw or 0-1 settles NO." "chess" 1000 0 0
# 100000000 = 1.0 coin of liquidity; 1000000 = 0.01
$CLI createtrade "$ADDR" "$MARKETID" buy 3 1 1
# 3 shares, at up to 1.00 a share, on outcome state 1
$CLI listtrades "$MARKETID"
Read positions from listtrades. That is the authoritative
record.
Then play it. The adjourned position below is the one the decision asks about — a textbook forced win, two moves deep. You are White; the page defends as Black. However the game ends, the result sheet fills in, and you can vote on it and watch where that vote lands against the field.
Loading the position…
White pieces are light, Black pieces are red. Dots mark legal moves; only legal moves are accepted.
No moves yet.
The decision text: Does White win board 1 of the club final? A draw is NO. Seven other voters vote what the sheet says. You are the eighth — how do you vote?
Finish the game first. A decision resolves on what happened, and nothing has happened yet.
Board 1 is a mate in two with a single defence. The four boards below go the other way: more defences, older games, and a decision text that pays only if the mate arrives by a stated move. A forced mate is the chess shape of a Hivemind decision. Before the key move there are many futures; after it, every reply has an answer, and the search is the proof — each defence, and its refutation. Play White and the page defends with the longest resistance it can find; or press PROVE THE MATE and read the tree shrink, move by move, until one fact is left.
Loading the position…
No moves yet.
11Privacy
Our builds have the upstream seed list removed, so your node does not announce itself to anyone else's network on startup — it connects to the Skydoge slot-9 seed and nowhere else. The binaries are stripped and contain no build paths, usernames or e-mail addresses. This page loads no fonts, scripts or trackers from anywhere but this server.
12Reporting something broken
Hivemind is early software running on the Skydoge testnet, and the interesting problems are the ones nobody has hit yet. If your wallet reports a balance it will not let you spend, or a market price that looks impossible, that is worth telling us about — both of those were real bugs found and fixed on the way to this build.