Requant

A proof-of-work coin (ticker RQT, provisional) whose work is the forward pass of a deep int8 network: the arithmetic that GPU tensor cores and AI inference accelerators are built for. The name is the step that makes the work hard to shortcut: exact integer requantization between layers. The work function is called TNet.

Status: pre-alpha; a public test network is running (TESTNET.md). Website, documentation, explorer, pool statistics and the Web Wallet: https://requant.network. The work function (TNet v1) is frozen with test vectors and reference implementations; a node, a wallet and a GPU miner exist; there is no main network and the test coins have no value. See ROADMAP.md. Nothing here is a security or investment claim.

Try the test network

1. Wallet. The quickest is the Web Wallet, or the same wallet in Telegram (@requant_wallet_bot); desktop, Android and browser-extension apps are on requant.network/docs/wallet. On the command line, download requant-wallet for Linux, Windows or Android (Termux) from the wallet release and make a wallet: requant-wallet create my.wallet shows a 24-word backup phrase (write it down) and your address (trq1...); requant-wallet address my.wallet prints it again with its key hash.

2. Test coins. The faucet sends 10 RQT to your address, once a day per address. Or buy test RQT for signet bitcoin, Lightning or test USDT on TRON Nile with an atomic swap (guide). Mined more than you need? Top the faucet up: trq1q8pqnx3uqer6jcxszen4tg3hylh5q645ae23yvra62a2nu98slqaqvvyume.

3. Mine. The GPU miner is CPPminer: NVIDIA Turing or newer on tensor cores (CUDA), and AMD and Intel GPUs over OpenCL (--backend opencl; Intel Arc on its XMX engines). Download cppminer-win64-cuda.zip or cppminer-linux-x64-cuda.tar.gz from the CPPminer releases, check the GPU with cppminer --algo tnet --selftest, and mine in the pool:

   cppminer --algo tnet --rpc pool.requant.network:19340 --payee <your key hash> --worker rig1

   The pool pays PPLNS (1% fee) automatically from 1 RQT, 100 blocks after a block is found; your devices and payouts are on the pool page.

4. Look around. Blocks, transactions and any address on the explorer; peers, pending transactions and watchman events on the reference node's network page.

5. Send. Without a node of your own the wallet uses the explorer's public API: requant-wallet balance my.wallet --api http://pool.requant.network:19380 and requant-wallet send my.wallet <address> 1.5 --api http://pool.requant.network:19380 (keys stay on your machine; that node sees which addresses you ask about).

6. Run a node (optional): requantd from the same release, requantd --network test --connect pool.requant.network:19333; the wallet then talks to it by default. With --auto-update it installs new signed releases by itself. Everything else: TESTNET.md.

How the work function works

Every epoch, eight 8192 x 8192 int8 weight matrices are derived from the chain. For each nonce, an input of 65,536 int8 rows is derived from the block header and pushed through the eight layers, with an exact integer requantization between them. Every 256-byte piece of an output row is a lottery ticket hashed with SHA-256. A block carries the winning ticket's (nonce, row, piece index, piece), 272 bytes. A node checks the hash, then recomputes that one row: about 11 ms on a laptop CPU.

• Miners run int8 matrix multiplication on tensor cores: about 99% of an attempt in CPPminer, which does the requantization inside the GEMM (88% in the research build on a Turing GPU). Computing fewer rows does not make a ticket cheaper.
• Verification needs no proof system and no trusted setup, only SHA-256 and integer arithmetic, plus 512 MiB of epoch weights.
• Shortcuts were tested in the research: approximate arithmetic produces no valid tickets, and table-based precomputation is bounded to be slower. See RATIONALE.md.

Full definition: SPEC.md. Chain rules (draft): CHAIN.md: one-minute blocks, a smooth emission of 2^24 RQT with a small tail, no premine, and a 6% development fund for the first four years that ends by itself. Transactions can lock coins under 2-of-2 keys or hash/time-locked contracts and carry absolute or relative time locks (CHAIN.md §4.1–4.2), the primitives for atomic swaps and payment channels. Built on them: swaps with a maker for bitcoin (on chain and over Lightning) and for USDT on TRON (requant-wallet swap, requant-maker, the RequantHtlc contract in contracts/), and one-way payment channels (requant-wallet channel), used by every Requant Wallet app and by MagnetGate. Monero and EVM swaps and two-way channels are designed, not built (SWAPS.md).

Quick start

Rust (stable; the tnet crate has no dependencies, the chain uses ed25519-dalek and serde_json) and Python 3.10+ with pytest:

python scripts/check.py                      # pytest, rustfmt, clippy -D warnings, cargo test
cargo test --release -- --ignored            # frozen-parameter vectors (512 MiB, ~15 s)
cargo run --release --bin tnet -- bench      # CPU verification time at the v1 parameters

GPU miner: CPPminer --algo tnet (see Try the test network); it mines in the pool or through a node's getwork/submitwork. GPU benchmark and parity tool: miner/cuda/.

A local regtest node that mines on the CPU (instant blocks, small work function):

cargo run --release --bin requantd -- --network regtest --mine <32-byte key hash, hex>
curl -s -X POST 127.0.0.1:19445 -d '{"method":"getinfo","params":[]}'

Wallet (regtest: add --network regtest): requant-wallet create my.wallet, then --mine <key hash> on the node, requant-wallet balance my.wallet, requant-wallet send my.wallet <address> 1.5; see TESTNET.md for the rest.

Layout

SPEC.md          TNet v1 work function (normative)
SWAPS.md         swaps and payment channels on the consensus primitives: design, privacy, open work
crates/tnet/     Rust reference: derivations, verifier (Epoch), CLI (vectors, check, bench)
crates/consensus/ chain rules of CHAIN.md: transactions, blocks, difficulty, emission, chain state
crates/node/     requantd: storage, peer-to-peer sync and relay, mempool, JSON-RPC, regtest miner
crates/wallet/   requant-wallet: 24-word wallets (BIP 39, SLIP-0010), offline signing, payments through a node,
                 swaps and channels; requant-maker, the swap maker (BTC, Lightning, USDT on TRON)
contracts/       RequantHtlc: the hash/time-locked contract for TRC-20/ERC-20 swaps (Solidity, Foundry tests)
reference/       pure-Python reference written from SPEC.md
vectors/         frozen test vectors
miner/cuda/      GPU attempt benchmark, the starting point of the miner
tests/           Python tests (reference vs vectors vs Rust)
scripts/check.py local gate

Background

Requant and TNet come out of the Abacus research lab, which tested linear-algebra proofs of work (Freivalds-verified matrix products, NTT, int8 GEMM with proofs) and recorded why most of them fail. TNet is its candidate T (ADR 0015/0016 there).

License

Apache License 2.0. See LICENSE and NOTICE.