TensorCash Core.

Compilar a partir do código-fonte

O artefacto canónico é a árvore de código-fonte em services/core-node/bcore/. A carteira Qt compila a partir do mesmo alvo CMake que o daemon sem interface — passa -DBUILD_GUI=ON ao configurar. Dois caminhos: um Dockerfile que compila toda a stack (mais simples, em ambiente isolado) ou dependências nativas no teu sistema (iteração mais rápida, imagem mais leve).

Caminho 1 · Docker (recomendado)

O repositório inclui um Dockerfile multi-fase que compila o binário Rust cosign-bridge, a wheel Python ChiaVDF e o daemon bcore completo + carteira Qt de uma só vez. Só precisas do Docker instalado no sistema. O contentor inclui também o Tor para redes de serviços ocultos e um servidor VNC para poderes executar a GUI dentro do contentor se quiseres.

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 \
  .

Após a compilação, executa o contentor expondo a porta RPC da carteira e (opcionalmente) VNC para acesso GUI:

# 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

Caminho 2 · Compilação nativa

Usa esta opção se quiseres binários nativos no teu sistema sem contentor. Testado em macOS 13+ (arm64 / x86_64) e Ubuntu / Debian; Fedora e Arch estão documentados em doc/build-unix.md dentro do submódulo bcore.

Clone

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

Instalar dependências — macOS

Primeiro as Xcode Command Line Tools, depois os pacotes Homebrew.

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

Instalar dependências — Linux (Ubuntu / Debian)

Mesma ideia, gestor de pacotes diferente. Fedora e Arch estão no doc/build-unix.md do repositório upstream.

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

Instalar dependências — Windows (compilação cruzada)

As compilações Windows nativas passam pelo MSVC (ver doc/build-windows-msvc.md). O caminho mais rápido usado pela maioria dos contribuidores é a compilação cruzada a partir de um sistema Linux (ou WSL) com a toolchain Mingw-w64 e o sistema de dependências incluído. O NSIS só é necessário para o alvo instalador .exe.

# 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)

Configurar + compilar

Em macOS / Linux a etapa de configuração é uma única invocação CMake. Em Windows passa o ficheiro de toolchain gerado pela árvore de dependências.

# 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

Opções de configuração comuns: -DBUILD_GUI=ON (carteira Qt), -DENABLE_WALLET=OFF (nó apenas de chain), -DWITH_ZMQ=ON (tópicos pub/sub ZMQ). Corre cmake -B build -LH para a lista completa.

Compilar o cosign bridge

As funcionalidades Cosign na carteira (assinatura com dispositivo emparelhado, multisig federado) comunicam com um binário Rust sidecar chamado cosign-bridge através de um socket local. O caminho Docker compila-o automaticamente; para compilações nativas, produz-o com 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.

Executar

O binário da carteira Qt fica em build/bin/. A sincronização inicial com a mainnet demora horas e escreve um chainstate de vários GB; para um teste rápido, aponta-o para um datadir regtest.

# 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

Consulta o guia regtest para a configuração completa de desenvolvimento local, incluindo validação simulada e os RPCs específicos da TensorCash.

Serviços complementares

O TensorCash Core é a carteira mais um pequeno conjunto de serviços sidecar com os quais comunica. A compilação Docker acima inclui todos eles; se compilares nativamente, são estes que montarias junto do binário Qt, consoante as funcionalidades que quiseres.

Binários de benfeitores

Compilar a partir do código-fonte é o caminho canónico. Por conveniência, benfeitores da comunidade publicam as suas próprias compilações do mesmo código-fonte. O projeto não produz, não assina nem distribui binários — são publicações independentes de terceiros, listadas aqui apenas a título informativo. Verifica qualquer compilação de benfeitor contra a tua, feita a partir do código-fonte, ou cruza-a com a de outro benfeitor.

Para constares como benfeitor: compila a partir de uma versão de código-fonte etiquetada, publica um manifesto SHA-256 dos teus artefactos e uma assinatura PGP destacada, e abre um pull request a adicionar uma linha a esta tabela.

Verificar uma compilação de benfeitor

Duas verificações. A primeira liga a afirmação do benfeitor ao binário que descarregaste; a segunda liga o binário ao código-fonte.

Hash + assinatura

Cada benfeitor publica um ficheiro SHA256SUMS e uma assinatura destacada SHA256SUMS.asc. Confirma que o ficheiro que descarregaste corresponde ao manifesto e que o manifesto está assinado com a chave PGP publicada pelo benfeitor.

# 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

Referência cruzada

A assinatura de um único benfeitor apenas prova que ele certifica o binário — não que o binário corresponda ao código-fonte. Duas formas de fechar essa lacuna: compilares tu próprio a partir do código-fonte e comparares os hashes, ou cruzares com o manifesto de um segundo benfeitor para a mesma etiqueta de versão. Quando dois ou mais compiladores independentes publicam SHA-256 idênticos para o mesmo artefacto, tens prova de que a compilação é reproduzível a partir do código-fonte público.

O que vem a seguir

• guia regtest — ambiente de desenvolvimento local com validação simulada, percursos de registo de modelo e emissão de ativos.
• Referência JSON-RPC — a consola integrada na carteira suporta todos os métodos desta referência.
• Envolve-te — todas as outras formas de participar: instituições, fornecedores, programadores, verificadores, investigadores.