/wallet

TensorCash Core.

En Qt-baserad skrivbordsplånbok för TensorCash-kedjan — härledd från Bitcoin Core, med stöd för nativa tillgångar och en inbyggd JSON-RPC-konsol. Bygg den själv från det publika källkodsträdet (med Docker eller nativt), eller hämta ett binärpaket publicerat av en välgörare nedan.

Rundtur

Samma form som Bitcoin Core, med TensorCash-specifika flikar för nativa tillgångar och emission. Klicka på en ruta för att se bilden i full upplösning.

Översikt · saldo, senaste transaktioner, nätverksstatus

1 / 12

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://github.com/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://github.com/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.

Tjänst	Källkodssökväg	Vad den gör	Behövs för
cosign-bridge	services/core-node/cosign-bridge/	Lokal Rust-sidecar som hanterar cosign / federerad-signeringsparkoppling (SPAKE2 + Noise via WebSocket). Hanterar parkopplade enhetsflöden från Qt-plånboken.	Cosign-funktioner (signering med flera enheter, federerad multisig)
ChiaVDF	shared-utils/chiavdf/	Verifierbar fördröjningsfunktion som används av kedjans validering. Byggs som en Python-wheel under daemon-bygget.	Validering av vilket block som helst (mainnet, testnet eller regtest)
core-node REST	services/core-node/src/	Litet REST-gränssnitt vid sidan av JSON-RPC-servern. Exponerar modellmetadata och nodmetrik.	Leverantörsintegrationer; plånboken själv behöver den inte
verification-api	services/verification-api/	OSS-verifieringstjänst. Plånboken anropar den inte direkt — det gör bcore, när -validationapi=real.	Riktig (icke-mock) blockvalidering i produktion
miner-api	services/miner-api/	Brygga mellan kedjan och inferensmotorn (llama.cpp / vLLM). Producerar inferensbeviset som ingår i ett block.	Mining (leverera inferens + producera block)

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.

Välgörare	Plattformar	PGP-nyckel	Anteckningar
TensorCash	macOS (arm64, x86_64) · Linux (x86_64) · Windows (x86_64)	pending	Bygger från det publika källkodsträdet. Varje release levereras med ett SHA-256-manifest och en fristående PGP-signatur bredvid binärerna.

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.