/wallet

TensorCash Core.

Una wallet de escritorio basada en Qt para la cadena TensorCash — derivada de Bitcoin Core, con soporte de activos nativos y consola JSON-RPC integrada. Compílala tú mismo desde el código fuente público (con Docker o de forma nativa), o descarga un binario de conveniencia publicado por un benefactor.

Tour

Misma estructura que Bitcoin Core, con pestañas propias de TensorCash para activos nativos y emisión. Haz clic en un panel para ver la imagen en resolución completa.

Resumen · saldo, transacciones recientes, estado de la red

1 / 12

Compilar desde el código fuente

El artefacto canónico es el código fuente en services/core-node/bcore/. La wallet Qt se compila desde el mismo objetivo CMake que el daemon sin interfaz — pasa -DBUILD_GUI=ON en el momento de la configuración. Dos opciones: un Dockerfile que compila toda la pila (lo más sencillo, en sandbox), o las dependencias nativas en tu máquina (iteración más rápida, imagen más ligera).

Opción 1 · Docker (recomendado)

El repositorio incluye un Dockerfile multietapa que compila el binario Rust de cosign-bridge, la wheel Python de ChiaVDF y el daemon completo bcore + wallet Qt de una sola vez. Solo necesitas Docker instalado en el host. El contenedor también incluye Tor para redes de servicios ocultos y un servidor VNC para ejecutar la interfaz gráfica dentro del contenedor si lo prefieres.

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

Tras la compilación, ejecuta el contenedor exponiendo el puerto RPC de la wallet y, opcionalmente, VNC para acceso a la interfaz gráfica:

# 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

Opción 2 · Compilación nativa

Úsala si quieres binarios nativos en tu máquina sin contenedor. Probado en macOS 13+ (arm64 / x86_64) y Ubuntu / Debian; Fedora y Arch están documentados en doc/build-unix.md dentro del submódulo bcore.

Clonar

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

Instalar dependencias — macOS

Primero las Xcode Command Line Tools, luego los paquetes de 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 dependencias — Linux (Ubuntu / Debian)

Mismo proceso, gestor de paquetes diferente. Fedora y Arch están en el doc/build-unix.md original del repositorio.

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 dependencias — Windows (compilación cruzada)

Las compilaciones nativas para Windows usan MSVC (ver doc/build-windows-msvc.md). La mayoría de los colaboradores prefieren la compilación cruzada desde un host Linux (o WSL) con la cadena de herramientas Mingw-w64 más el sistema de dependencias incluido. NSIS solo es necesario para el objetivo 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

En macOS / Linux, el paso de configuración es una única invocación de CMake. En Windows, pasa el archivo de toolchain generado por el árbol de dependencias.

# 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

Flags de configuración habituales: -DBUILD_GUI=ON (wallet Qt), -DENABLE_WALLET=OFF (nodo solo de cadena), -DWITH_ZMQ=ON (tópicos ZMQ pub/sub). Ejecuta cmake -B build -LH para ver la lista completa.

Compilar el puente cosign

Las funciones cosign de la wallet (firma entre dispositivos emparejados, multisig federado) se comunican con un binario Rust de acompañamiento llamado cosign-bridge a través de un socket local. La opción Docker lo compila automáticamente; en compilaciones nativas, lo generas con 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.

Ejecutar

El binario de la wallet Qt queda en build/bin/. La sincronización inicial con mainnet puede tardar horas y escribe varios GB de chainstate; para una prueba rápida, usa un datadir de 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 la guía de regtest para el entorno completo de desarrollo local, con validación simulada y los RPCs específicos de TensorCash.

Servicios complementarios

TensorCash Core es la wallet, junto con un pequeño conjunto de servicios de acompañamiento con los que se comunica. La compilación con Docker los incluye todos; si compilas de forma nativa, estos son los que montarías junto al binario Qt según las funcionalidades que quieras.

Servicio	Ruta del código fuente	Qué hace	Necesario para
cosign-bridge	services/core-node/cosign-bridge/	Servicio auxiliar Rust local que gestiona el emparejamiento cosign / firma federada (SPAKE2 + Noise sobre WebSocket). Da soporte a los flujos de dispositivos emparejados desde la wallet Qt.	Funciones cosign (firma multi-dispositivo, multisig federado)
ChiaVDF	shared-utils/chiavdf/	Función de Retraso Verificable (VDF) utilizada por la validación de la cadena. Se compila como wheel Python durante la compilación del daemon.	Validar cualquier bloque (mainnet, testnet o regtest)
core-node REST	services/core-node/src/	Pequeña interfaz REST junto al servidor JSON-RPC. Expone metadatos de modelo y métricas del nodo.	Integraciones de proveedor; la wallet en sí no lo necesita
verification-api	services/verification-api/	Servicio de verificación open-source. La wallet no lo llama directamente — lo hace bcore, cuando se usa -validationapi=real.	Validación real de bloques (no simulada) en producción
miner-api	services/miner-api/	Actúa como puente entre la cadena y el motor de inferencia (llama.cpp / vLLM). Genera la prueba de inferencia que forma parte de un bloque.	Minería (servir inferencia y producir bloques)

Binarios de benefactores

Compilar desde el código fuente es el camino canónico. Por comodidad, benefactores de la comunidad publican sus propias compilaciones del mismo código fuente. El proyecto no produce, firma ni distribuye binarios — son publicaciones independientes de terceros, listadas aquí solo a modo de referencia. Verifica cualquier compilación de benefactor contra tu propia compilación desde fuente, o contrástala con la de otro benefactor.

Benefactor	Plataformas	Clave PGP	Notas
TensorCash	macOS (arm64, x86_64) · Linux (x86_64) · Windows (x86_64)	pending	Compila desde el código fuente público. Cada versión incluye un manifiesto SHA-256 y una firma PGP independiente junto a los binarios.

Para aparecer como benefactor: compila desde una versión etiquetada del código fuente, publica un manifiesto SHA-256 de tus artefactos y una firma PGP independiente, y abre un pull request añadiendo una fila a esta tabla.

Verificar una compilación de benefactor

Dos comprobaciones. La primera vincula la afirmación del benefactor con el binario que descargaste; la segunda vincula el binario con el código fuente.

Hash + firma

Cada benefactor publica un archivo SHA256SUMS y una firma SHA256SUMS.asc independiente. Confirma que el archivo que descargaste coincide con el manifiesto, y que el manifiesto está firmado con la clave PGP publicada por el benefactor.

# 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

Verificación cruzada

La firma de un solo benefactor solo prueba que avala el binario — no que el binario coincida con el código fuente. Dos formas de cerrar esa brecha: compila desde el código fuente y compara los hashes, o contrasta con el manifiesto de un segundo benefactor para la misma etiqueta de versión. Cuando dos o más compiladores independientes publican SHA-256 idénticos para el mismo artefacto, ya tienes pruebas de que la compilación es reproducible desde el código fuente público.

¿Qué sigue?

guía de regtest — entorno de desarrollo local con validación simulada, y recorridos de registro de modelos y emisión de activos.
Referencia JSON-RPC — la consola integrada de la wallet soporta todos los métodos de esta referencia.
Participa — todas las demás formas de participar: instituciones, proveedores, desarrolladores, verificadores, investigadores.