Regtest-guide

Tre lokale utviklingsveier, sortert etter friksjon. Hver av dem gir deg en TensorCash-JSON-RPC du kan kalle med bitcoin-cli eller en hvilken som helst JSON-RPC-klient. Den funksjonelle testpakken i bcore er den kanoniske, kjørbare spesifikasjonen for alt nedenfor, og hver gjennomgang lenker til testen den er hentet fra.

Bare Core · docker compose · funksjonelle tester

Valideringsmoduser

TensorCash legger til et eksternt valideringssteg i blokkaksepten. -validationapi velger backenden som utfører det, og det er det viktigste valget for en lokal kjøring: det avgjør om du trenger en GPU, en verifikatorprosess eller ingen av delene.

FlaggHva det erNår du bør bruke den
-validationapi=realStandardvalget. Snakker med en ekstern verifikator over ZMQ PUSH/PULL-kanalen mellom node og verifikator med FlatBuffers. Produksjonsinnstillingen.Krever en ekte verifikatorprosess. Brukes på hovednettet, testnettet og alle regtest-kjøringer som tester ekte modellavspilling.
-validationapi=mockI prosessen og deterministisk. Mock-backenden eksponerer tre RPC-er (validationmockdefault, validationmockclear, validationmockrequests) for forhåndsdefinerte Quick-, Full- og Model-svar; med oppstartsflaggene -mockval-default-* kan hvert verifiseringsutfall styres med skript.Standard for den funksjonelle testpakken. Riktig valg når du vil teste kjedelogikken uten verifikator eller ekte inferens.
-validationapi=desktopHybrid. Quick-kontroller kjører i prosessen; Full og Model sendes til en lokal HTTPS-verifikator (standard skrivebordsbinærfil). Ingen ZMQ-megler nødvendig.Demoer på én maskin som vil ha en ekte Quick- og Smell-kontroll uten å drifte en separat verifikatortjeneste.

For en første titt på kjedelogikken er mock riktig svar. Resten av siden forutsetter det, med mindre annet er oppgitt.

Vei A · bare Core, med mock-validering

Minst friksjon. Én C++-daemon: ingen docker, ingen GPU, ingen modellfiler på disk. Nok for alle gjennomgangene på denne siden.

1. Bygg daemonen

Følg byggeinstruksjonene for Bitcoin Core mot services/core-node/bcore/. TensorCash-koden bygges under det samme CMake-målet som oppstrøms; det finnes ikke noe eget flagg.

2. Start en regtest-node

Disse flaggene speiler det test_framework/test_tensorcash.py sender til hver funksjonelle test, så alt som kjører der, kjører også her. Standard mock-svar er låst til grønt, så blokkaksept er deterministisk.

./bitcoind \
  -datadir=$HOME/.tensorcash-regtest \
  -regtest \
  -vdfspvcommitmentheight=0 \
  -vdfspvvdfverifyheight=0 \
  -maxtipage=999999 \
  -spv-asn-min=1 \
  -spv-hysteresis-base-bps=0 \
  -spv-reorg-sampling-threshold=999 \
  -useextapi=0 \
  -par=1 \
  -debug=net -debug=validation \
  -validationapi=mock \
  -mockval-force-external=1 \
  -mockval-default-quick=quick_ok_smell_ok \
  -mockval-default-full=full_green \
  -mockval-default-model=model_ok \
  -daemon

3. Send kall til noden

Autentisering bruker cookie-filen i $HOME/.tensorcash-regtest/regtest/.cookie, som bitcoin-cli leser automatisk når du sender med -datadir. RPC-porten er oppstrøms standard for regtest, 18443.

alias bcli='bitcoin-cli -regtest -datadir=$HOME/.tensorcash-regtest'
bcli getblockchaininfo | jq '{chain, blocks, verificationprogress}'

Vei B · hele den lokale stakken (docker compose)

For når mock ikke er nok: en ekte verifikatorprosess, en ekte modell som leverer inferens, og miner-API-et koblet inn. Rotkatalogen i repositoriet har oppstartsskript for Mac og for Linux med CUDA.

På Apple silicon henter oppstartsskriptet et llama.cpp-bygg og starter hele compose-stakken core-node + miner-api + verification-api:

export GITHUB_TOKEN="ghp_..."
export MODEL_FILE="$HOME/models/Qwen_Qwen3_8B.gguf"
./launch_macbook.sh
# brings up: core-node (RPC 18443, REST 8050) + miner-api + verification-api

På Linux med NVIDIA-GPU-er gjør launch_linux.sh det samme, med den vLLM-baserte verifikatoren i stedet for llama.cpp:

export API_KEY=super-secret-token
export MODEL_API_KEY=super-secret-token
sudo ./launch_linux.sh
# uses deployments/docker-compose/core-miner-validation-api/docker-compose.yaml

Compose-filen binder vertsportene 8333 (P2P), 8050 (core-node REST-API) og 7067 (ZMQ). Verifikatoren leverer sitt Verifier-REST-API på sin egen containerport.

Vei C · kjør den funksjonelle testpakken

Når daemonen er bygget (vei A, steg 1), starter testkjøreren engangsnoder for deg. Nyttig når du vil ha en kjent, fungerende sekvens å kopiere fra, heller enn en daemon å eksperimentere med.

cd services/core-node/bcore

# Single test
build/test/functional/test_runner.py feature_model_registration.py

# All TensorCash-specific tests
build/test/functional/test_runner.py 'feature_model_*' 'feature_asset*' 'feature_fairsign_*'

# All tests, parallelised
build/test/functional/test_runner.py --jobs=$(nproc)

TensorCash-testene er gruppert etter grensesnitt: modellens livssyklus, native aktiva, fair-sign-adaptorer og covenant-repo-lommeboken. Hver er et selvstendig scenario du kan lese fra topp til bunn; gjennomgangene nedenfor peker på de mest representative.

Gjennomganger

Tre korte sekvenser mot mock-noden fra vei A. Hver av dem er en skisse; den lenkede funksjonelle testen er hele det kjørbare scenarioet.

Mine den første blokken din

Kanonisk test: wallet_basic.py

Uendret fra Bitcoin Core. En røyktest før noe TensorCash-spesifikt grensesnitt: den bekrefter at daemonen kjører og at lommeboken har midler.

Berører: createwallet, getnewaddress, generatetoaddress, getbalance

# bitcoin-cli speaks to the regtest daemon over the cookie file.
ALIAS="bitcoin-cli -regtest -datadir=$HOME/.tensorcash-regtest"

$ALIAS createwallet sandbox
ADDR=$($ALIAS -rpcwallet=sandbox getnewaddress)
$ALIAS -rpcwallet=sandbox generatetoaddress 101 "$ADDR"
$ALIAS -rpcwallet=sandbox getbalance
# 50.00000000  (block 1's coinbase, mature after 100 confirmations)

Registrer en modell fra start til slutt

Kanonisk test: feature_model_registration.py

TensorCash-spesifikt. En modell registreres ved å sette et depositum i escrow, samle vellykkede Quick- og Model-verifiseringer over N commits og deretter gå over til registered når verifiseringsvinduet lukkes. Med -validationapi=mock kan du styre hvert steg fra RPC-er, uten ekte verifikator eller GPU. Dette er en skisse; den lenkede testen er hele scenarioet.

Berører: validationmockdefault, createmodeldeposit, createmodelcommit, getmodelstatus, generatetoaddress

# Pin every mock rung to the green response.
$ALIAS validationmockdefault quick quick_ok_smell_ok
$ALIAS validationmockdefault model model_ok
$ALIAS validationmockdefault full  full_green

# Lay down 101 spendable coinbase outputs.
$ALIAS -rpcwallet=sandbox generatetoaddress 101 "$ADDR"

# 1. Escrow the deposit (1_000_000 sats == 0.01 BTC).
DEPOSIT=$($ALIAS -rpcwallet=sandbox createmodeldeposit \
  tensor/registration-success success-commit 1000000)
TXID=$(echo "$DEPOSIT" | jq -r .txid)
VOUT=$(echo "$DEPOSIT" | jq -r .deposit_vout)
HASH=$(echo "$DEPOSIT" | jq -r .model_hash)
$ALIAS -rpcwallet=sandbox generatetoaddress 1 "$ADDR"

# 2. Accumulate 50 commits — feature_model_registration.py shows the funding
#    plumbing in detail. Then mine to the verification window's close height.
# 3. Poll status.
$ALIAS getmodelstatus "$HASH"
# {"status": "registered", "verification_code": 0, ...}

Utsted et native aktivum

Kanonisk test: feature_assets_basic_highlevel.py

TensorCash-spesifikt. registerasset er lommebokens høynivå-RPC som bygger depositums- og ICU-utgangene, legger ved utstederregistreringens TLV og kringkaster. Etter én bekreftelse kan aktivumet slås opp etter ID eller ticker. Hele livssyklusen (preging, overføring, brenning) finnes i den lenkede testen.

Berører: registerasset, getassetpolicy, getassetbyticker, getassetbalance

ADDR=$($ALIAS -rpcwallet=sandbox getnewaddress)
ASSET_ID=$(printf 'my-first-asset' | shasum -a 256 | cut -d' ' -f1)

$ALIAS -rpcwallet=sandbox registerasset \
  "$ADDR"          `# ICU address` \
  5.1              `# bond (BTC)` \
  "$ASSET_ID"      `# 32-byte asset id` \
  3                `# policy bits: MINT | BURN` \
  28               `# allowed families: P2WPKH | P2WSH | P2TR` \
  510000000        `# unlock fees (sats)` \
  TST              `# ticker` \
  8                `# decimals` \
  '{"autofund":true,"broadcast":true,"fee_rate":10}'

$ALIAS -rpcwallet=sandbox generatetoaddress 1 "$ADDR"
$ALIAS getassetpolicy "$ASSET_ID"
$ALIAS getassetbyticker TST

Flaggreferanse

Flaggene fra vei A som skiller seg fra en vanlig bitcoind -regtest-økt. Autoritativ kilde: test_framework/test_tensorcash.py og init.cpp.

FlaggHvorfor det betyr noe i regtest
-regtestVelger regtest-kjeden (blokksubsidie, regler for umiddelbar modenhet og de lokale portene 18443/18444).
-vdfspvcommitmentheight=0Aktiverer VDF/SPV fra genesis i stedet for fra den trinnvise aktiveringshøyden på hovednettet.
-vdfspvvdfverifyheight=0Aktiverer VDF-verifisering fra genesis.
-maxtipage=999999Godtar gamle tidsstempler, slik at en omstart på en utdatert kjede ikke ser ut som en usynkronisert node.
-spv-asn-min=1Senker gulvet for ASN-bekreftelse; uten det blokkerer regtest VDF-SPV-byttelogikken.
-spv-hysteresis-base-bps=0Fjerner basismargin-hysteresen, slik at reorgs i tester skjer umiddelbart og deterministisk.
-spv-reorg-sampling-threshold=999Slår i praksis av stikkprøvekontroll av blokkinnhold ved dype reorgs, som er upraktisk å utløse ved lave høyder.
-useextapi=0Slår av det eksterne miner-API-et: ikke nødvendig for gjennomganger som bare gjelder kjeden, og det korter ned oppstarten.
-debug=net,validationLogger de mest nyttige linjene for en regtest-økt: nettverk og valideringskjeden.
-par=1Enkelttrådet validering. Fjerner en klasse ustabilitet som bare oppstår i tester, uten å påvirke korrektheten.

Videre herfra

  • JSON-RPC-referanseHele metodeoversikten, ordnet etter kategori, med stabilitetsmerker og curl-eksempler.
  • Verifier-REST-APINår du går fra -validationapi=mock til en ekte verifikatorprosess.
  • FlatBuffer-skjemaerFlatBuffer-IDL og JSON Schema for ZMQ-nyttelastene mellom node og verifikator.
  • bcore/test/functional/Les testene som spesifikasjonen.
  • Testnett-faucetDen nettbaserte motparten: fyll på en lommebok på det delte testnettet når du vil ha en levende kjede i stedet for en lokal sandkasse.