TensorCash Core.

Bygg från källkod

Det kanoniska artefaktet är källkodsträdet på services/core-node/bcore/. Qt-plånboken byggs från samma CMake-mål som den headless-demonen — skicka med -DBUILD_GUI=ON vid konfigurering. Två vägar: en Dockerfile som bygger hela stacken (enklast, sandboxad), eller nativa beroenden på din värd (snabbare iteration, mindre image-storlek).

Väg 1 · Docker (rekommenderas)

Projektet levereras med en flerstegs-Dockerfile som bygger cosign-bridge Rust-binären, ChiaVDF Python-wheelen och den fullständiga bcore-demonen + Qt-plånboken i ett enda steg. Du behöver bara ha Docker installerat. Containern innehåller även Tor för hidden-service-nätverk och en VNC-server om du vill köra GUI:t inuti containern.

Dockerfile: services/core-node/tor.Dockerfile

git clone --recurse-submodules https://git.tensorcash.org/tensorcash/tensorcash.git
cd tensorcash

docker build \
  -f services/core-node/tor.Dockerfile \
  -t tensorcash-core:dev \
  .

Efter bygget, kör containern och exponera plånbokens RPC-port och (valfritt) VNC för GUI-åtkomst:

# Headless daemon, RPC reachable on host:18332.
docker run --rm -p 18332:18332 \
  -v $HOME/.tensorcash-data:/data \
  tensorcash-core:dev

# With the Qt GUI exposed via VNC on host:5900 (default password in the
# container's vnc.sh — change before any non-localhost binding).
docker run --rm -p 5900:5900 -p 18332:18332 \
  -v $HOME/.tensorcash-data:/data \
  tensorcash-core:dev

Väg 2 · Nativt bygge

Välj den här vägen om du vill ha nativa binärer på din värd utan container. Testad på macOS 13+ (arm64 / x86_64) och Ubuntu / Debian; Fedora och Arch finns dokumenterade i bcore-submodulens doc/build-unix.md.

Klona

git clone --recurse-submodules https://git.tensorcash.org/tensorcash/tensorcash.git
cd tensorcash/services/core-node/bcore

Installera beroenden — macOS

Xcode Command Line Tools först, sedan Homebrew-paket.

xcode-select --install   # if not already installed

brew install \
  cmake boost pkgconf libevent \
  qt@6 qrencode \
  zeromq \
  capnp                  # optional, only if you want -DENABLE_IPC=ON

Installera beroenden — Linux (Ubuntu / Debian)

Samma princip, annan pakethanterare. Fedora och Arch finns i upstream doc/build-unix.md inuti projektet.

sudo apt-get install -y \
  build-essential cmake pkgconf python3 \
  libevent-dev libboost-dev libsqlite3-dev libzmq3-dev \
  qt6-base-dev qt6-tools-dev qt6-l10n-tools qt6-tools-dev-tools libgl-dev \
  libqrencode-dev

Installera beroenden — Windows (korskompilering)

Nativa Windows-byggen görs via MSVC (se doc/build-windows-msvc.md). Den snabbare vägen som de flesta bidragsgivare använder är korskompilering från en Linux-värd (eller WSL) med Mingw-w64-verktygskedjan och det medföljande depends-systemet. NSIS behövs bara för .exe-installationsmålet.

# On a Linux host (or WSL inside Windows):
sudo apt-get install -y g++-mingw-w64-x86-64-posix nsis

# Build the depends tree once.
gmake -C depends HOST=x86_64-w64-mingw32 -j$(nproc)

Konfigurera + kompilera

På macOS / Linux är konfigureringssteget ett enda CMake-anrop. På Windows skickar du med verktygsfilen som genereras av depends-trädet.

# macOS / Linux
cmake -B build -DBUILD_GUI=ON
cmake --build build -j$(getconf _NPROCESSORS_ONLN 2>/dev/null || nproc)

# Windows (cross-compile from Linux/WSL)
cmake -B build --toolchain depends/x86_64-w64-mingw32/toolchain.cmake -DBUILD_GUI=ON
cmake --build build -j$(nproc)
cmake --build build --target deploy   # produces the .exe installer via NSIS

Vanliga konfigureringsflaggor: -DBUILD_GUI=ON (Qt-plånboken), -DENABLE_WALLET=OFF (kedjenod utan plånbok), -DWITH_ZMQ=ON (ZMQ pub/sub-ämnen). Kör cmake -B build -LH för den fullständiga listan.

Bygg cosign-bryggan

Cosign-funktioner i plånboken (parkopplad signering, federerad multisig) kommunicerar med en sidecar Rust-binär kallad cosign-bridge via en lokal socket. Docker-vägen bygger den automatiskt; för nativa byggen producerar du den med cargo:

# Rust 1.85+ required.
cd services/core-node/cosign-bridge
cargo build --release --bin cosign-bridge --bin cosign-local-relay
# Binaries land in target/release/. Run cosign-bridge alongside the wallet.

Kör

Qt-plånbokens binär hamnar i build/bin/. En första synkronisering mot mainnet tar timmar och skriver ett chainstate på flera GB; för ett snabbt röktest, peka i stället på ett regtest-datakatalog.

# Smoke test on a private chain — no real coins, no peers, no IBD.
build/bin/bitcoin-qt -regtest -datadir=$HOME/.tensorcash-regtest

# Production: starts initial block download against the live network.
build/bin/bitcoin-qt

Se regtest-guiden för den fullständiga lokala utvecklingsmiljön, inklusive mock-validering och TensorCash-specifika RPC:er.

Kompletterande tjänster

TensorCash Core är plånboken plus en liten uppsättning sidecar-tjänster den kommunicerar med. Docker-bygget ovan buntar ihop alla; om du bygger nativt är det här vad du sätter ihop vid sidan av Qt-binären, beroende på vilka funktioner du vill ha.

Välgörarnas binärer

Att bygga från källkod är den kanoniska vägen. Som en praktisk genväg publicerar välgörare i gemenskapen sina egna byggen av samma källkodsträd. Projektet producerar, signerar eller distribuerar inte binärer — dessa är oberoende tredjepartspublikationer, listade här endast informativt. Verifiera alla välgörarbyggen mot ditt eget källkodsbygge, eller jämför mellan välgörare.

Convenience binaries are published by community benefactors and listed in the network directory. Those listings are unverified and not endorsed by the project — always verify a build's PGP signature against the public source (below) before you run it.

För att listas som välgörare: bygg från en taggad källkodsrelease, publicera ett SHA-256-manifest över dina artefakter och en fristående PGP-signatur, och öppna en pull request som lägger till en rad i den här tabellen.

Verifiera ett välgörarbygge

Två kontroller. Den första kopplar välgörarens påstående till binären du laddade ner; den andra kopplar binären till källkoden.

Hash + signatur

Varje välgörare publicerar en SHA256SUMS-fil och en fristående SHA256SUMS.asc-signatur. Bekräfta att filen du laddade ner matchar manifestet, och att manifestet är signerat med välgörarens publicerade PGP-nyckel.

# 1. Manifest matches the binary you have on disk.
shasum -a 256 -c SHA256SUMS --ignore-missing

# 2. Manifest is signed by the benefactor's key.
gpg --verify SHA256SUMS.asc SHA256SUMS

Korsreferens

En enskild välgörares signatur bevisar bara att de intygar binären — inte att binären matchar källkoden. Två sätt att täppa till det gapet: bygg från källkod själv och jämför hasharna, eller jämför mot en annan välgörares manifest för samma release-tagg. När två eller fler oberoende byggen publicerar identiska SHA-256:or för samma artefakt har du bevis på att bygget är reproducerbart från publik källkod.

Vart härnäst

• regtest-guide — lokal utvecklingssandlåda med mock-validering samt genomgångar för modellregistrering och tillgångsemission.
• JSON-RPC-referens — den inbyggda konsolen i plånboken stöder varje metod i den här referensen.
• Delta i projektet — alla andra sätt att delta: institutioner, leverantörer, utvecklare, verifierare, forskare.