Tensorium: A Zero-Premine Proof-of-Work Blockchain Secured by TensorHash v1

1 Introduction

1.1 Motivation

Proof-of-Work blockchains have proven to be the most resilient consensus mechanism in practice. Bitcoin's 15-year track record demonstrates that PoW provides objective security without relying on stake concentration or trusted validator sets. However, most modern PoW chains are dominated by ASIC manufacturers, leaving community miners — particularly GPU operators — with few viable options.

Tensorium is built to address this: a clean, open PoW chain where GPU miners are first-class participants, the emission schedule is transparent and non-inflationary, and the codebase is fully open-source with zero premine and zero founder allocation — every coin in existence is mined.

1.2 Design Principles

• Fair launch, no exceptions. Zero premine, zero founder allocation, zero insider distribution. The genesis block holds nothing spendable — the entire 33,000,000 TXM supply is issued purely through mining.
• GPU-first, memory-hard mining. Mainnet runs on TensorHash v1, a memory-hard algorithm built around a multi-gigabyte per-epoch dataset — raw compute and VRAM, not specialized ASICs, decide who mines.
• Open source, always. All node, miner, and wallet code is published under an open license (Apache-2.0).
• Self-custody. Users control their own keys. No custodial wallets.
• Security before speed. Consensus rules were frozen before mainnet launch. No shortcuts.

1.3 Scope of This Document

This whitepaper covers the protocol design, consensus mechanism, tokenomics, and roadmap of the Tensorium network. Mainnet (tensorium-mainnet, TensorHash v1) is live. This is a living document and will be updated as the protocol evolves.

1.4 Current Public Surfaces

Tensorium is no longer just a node binary and a miner. The current public stack already includes the operational surfaces needed for testing, onboarding, and later ecosystem growth:

• Explorer. explorer.tensoriumlabs.com for blocks, transactions, addresses, mempool, and basic chain charts.
• Public RPC. rpc.tensoriumlabs.com for wallet and integrator access to the live chain.
• Pool website. pooltxm.tensoriumlabs.com for the reference pool, 5% fee disclosure, and miner-facing stats. Pool mining: tensorium-miner --mode pool --pool stratum+tcp://pooltxm.tensoriumlabs.com:3333 --wallet <address> --worker <name>. The website shows pool ledger entries only; direct/solo-mined blocks remain visible on-chain in the explorer.
• Bridge and DEX. bridge.tensoriumlabs.com — live bridge to Optimism (wTXM at 0x4EC59b2ED22645B2c62380C43cE3a732F7827b20, Controller 0x4DaA17B88AF791b9642bB2c96EB26FbAEE13afD1). otc.tensoriumlabs.com for OTC trades.
• Browser wallet. A Chrome-compatible wallet extension is implemented in tensorium-wallet-extension; Chrome Web Store submission is still pending.

2 System Architecture

2.1 Components

The Tensorium software stack consists of four independently runnable binaries:

2.2 Block Structure

Each block consists of a header and a list of transactions:

{
  "header": {
    "version":           1,
    "chain_id":          "tensorium-mainnet",
    "height":            uint64,
    "previous_hash":     Hash256,
    "merkle_root":       Hash256,
    "timestamp_seconds": uint64,
    "leading_zero_bits": uint8,     // current difficulty
    "nonce":             uint64
  },
  "transactions": [ Transaction, ... ]
}

The block hash is computed by TensorHash v1, Tensorium's memory-hard proof-of-work function (see §3.1). A block is valid if its hash has at least leading_zero_bits leading zero bits.

2.3 Transaction Structure

Transactions follow a UTXO (Unspent Transaction Output) model:

{
  "id":      Hash256,            // hash of transaction data
  "inputs":  [ { prev_txid, output_index, signature_script } ],
  "outputs": [ { address, value_atoms } ],
  "payload": bytes               // coinbase: encodes height + reward + miner
}

Coinbase transactions (block rewards) have empty inputs. All other transactions must reference existing UTXOs and provide valid secp256k1 ECDSA signatures.

2.4 UTXO Set

The node maintains a UTXO set that is updated with each accepted block. Coinbase UTXOs are subject to a 10-block maturity requirement before they can be spent, providing protection against short reorgs invalidating mining rewards.

2.5 Chain State

Chain state is persisted to a RocksDB directory (tensorium-mainnet-state.db/ by default). The canonical chain is the one with the greatest cumulative work, where block work is defined as 2^leading_zero_bits.

3 Consensus Mechanism

3.1 Proof-of-Work — TensorHash v1

TensorHash v1 is Tensorium's memory-hard, GPU-first Proof-of-Work function. For each ~8,192-block epoch, a deterministic dataset of 600,000,000 32-byte elements (~19.2 GB) is generated from the epoch seed. Mining requires materializing this dataset in VRAM and, for each candidate nonce, sampling K = 32 dataset elements to derive the candidate hash. Verification is cheap — a verifier recomputes only the K elements an attempt touches — while mining is memory-bound, since recomputing per-attempt is roughly K× slower than holding the dataset resident.

To mine a valid block, a miner must find a nonce such that:

leading_zero_bits( TensorHash_v1( serialize(header), epoch_dataset ) ) ≥ D

where D is the current difficulty in leading zero bits. The expected number of hash attempts per valid block is 2^D.

3.2 Difficulty Adjustment

Difficulty is adjusted every 60 blocks (one window) to target a 60-second block time:

actual_time   = timestamp(block_N) - timestamp(block_{N-60})
target_time   = 60 blocks × 60 seconds = 3,600 seconds
ratio         = actual_time / target_time
ratio         = clamp(ratio, 0.25, 4.0)     // max 4× adjustment per window

new_difficulty = old_difficulty + 1   if ratio < 1.0  (blocks too fast)
               = old_difficulty - 1   if ratio > 1.0  (blocks too slow)
               = old_difficulty        if ratio == 1.0

The ±1 bit per window cap prevents sudden difficulty spikes that could stall the chain or enable rapid mining attacks. Difficulty is bounded between min_leading_zero_bits (34 on mainnet) and max_leading_zero_bits (58 on mainnet).

3.3 Fork Choice Rule

When competing chain tips exist, the canonical chain is determined by greatest cumulative work:

cumulative_work(chain) = Σ  2^(leading_zero_bits_i)  for each block i

When a higher-work chain is received, the node performs a chain reorganization: it identifies the common ancestor, reverts blocks from the old tip back to the fork point, and applies the new chain's blocks. Reorg depth is logged to allow monitoring.

3.4 Genesis Block

The tensorium-mainnet genesis block is hardcoded in the node binary and produces an identical genesis block hash on every node:

Chain ID:     tensorium-mainnet
Difficulty:   42 bits
Algorithm:    TensorHash v1
Genesis allocations: none — zero premine, mining-only issuance from block 0

4 Tokenomics

4.1 Supply Summary

4.2 Emission Schedule

Block rewards halve every 2,102,400 blocks (~4 years at the 60-second target) across 10 eras (~40 years total). After era 10, no new TXM is issued — the network is sustained by transaction fees.

4.3 Zero Premine

Tensorium mainnet (tensorium-mainnet) launched with no genesis allocations of any kind. The genesis block holds nothing spendable — founder_allocation_atoms = 0 and mining_allocation_atoms = 33,000,000 TXM are enforced as consensus parameters in the node software. Key properties:

• No founder, team, advisor, or insider allocation — ever
• No pre-sale, no private round, no vesting unlocks to track
• Every TXM that exists or will ever exist is the direct output of a block reward to a miner
• Liquidity for the wTXM bridge pool on Optimism is sourced from mined supply, not a genesis grant
• Enforced by consensus — not a social commitment, not a lock schedule

4.4 Official Pool Fee

The official/reference pool charges a transparent 5% pool fee at payout accounting level. This is not a protocol-level miner tax. Solo mining remains fee-free at the consensus layer.

4.5 Transaction Fees

After era 10 (~year 2045), block rewards cease. The network is sustained entirely by transaction fees included in blocks by miners. Fee market mechanics will be refined based on observed live-network usage patterns.

5 Mining

5.1 Mining Architecture

Mining in Tensorium is a two-step process:

1. Get block template — the miner requests a candidate block from the node RPC (GET /getblocktemplate/<address>). The template includes pending mempool transactions and the current difficulty target.
2. Find valid nonce — the miner iterates the 64-bit nonce field, computing TensorHash v1 of the block header for each value, until a hash with sufficient leading zero bits is found.
3. Submit — the mined block is submitted to the node via POST /submitblock, which validates, stores, and broadcasts it to peers.

5.2 Solo Mining (GPU)

Mainnet difficulty starts at 42 bits — a GPU (RTX 3000+) is required. Connect tensorium-miner directly to your own node RPC for zero-fee solo mining.

tensorium-miner --mode solo --rpc http://127.0.0.1:33332 --wallet <address> --gpu all --intensity auto

# Example:
tensorium-miner --mode solo --rpc http://127.0.0.1:33332 --wallet txm1youraddress --gpu all --intensity auto

5.3 GPU Hashrate Reference

tensorium-miner supports NVIDIA GPUs (RTX 3000/4000/5000 series). Build with make ARCH=sm_86 (RTX 3080/4080) or sm_90 (H100).

At difficulty 36–38 bits, average block time converges toward the 60-second target through difficulty auto-adjustment. Datacenter GPUs (H100, H200) have no meaningful advantage over high-end gaming GPUs for TensorHash v1 — the algorithm is compute-bound and does not benefit from HBM bandwidth.

5.4 Mining Pool Support

The official/reference pool is live at pooltxm.tensoriumlabs.com. It exposes a Stratum miner endpoint at pooltxm.tensoriumlabs.com:3333, records payout accounting, discloses the 5% fee, and shows gross reward, fee, and net miner payout.

The pool website is intentionally pool-only: it represents pool ledger/accounting activity, not every block mined on-chain. Direct or solo-mined blocks settle straight to the miner wallet and should be checked in the explorer.

6 P2P Network

6.1 Protocol

Tensorium uses a custom lightweight P2P protocol over TCP. All messages are newline-delimited JSON. Each connection begins with a bidirectional handshake:

// Hello (both sides send simultaneously)
{
  "protocol":  "tensorium-p2p",
  "version":   1,
  "chain_id":  "tensorium-mainnet",
  "node_id":   "node-name",
  "height":    uint64,
  "tip_hash":  Hash256
}

After handshake, the following messages are supported:

6.2 Peer Discovery

The current implementation uses static peer configuration via the TENSORIUM_PEERS environment variable plus the built-in default seed in the node binary. For mainnet infrastructure, the canonical DNS seed is seed.tensoriumlabs.com:33333.

6.3 Peer Ban Policy

Nodes maintain a score-based ban list to protect against malicious peers:

Bans last 1 hour and are persisted to disk. Nodes can be manually unbanned via tensorium-node unban <ip>.

6.4 Network Ports

7 Security Considerations

7.1 51% Attack Resistance

As with all PoW chains, Tensorium is vulnerable to 51% hash power attacks. The GPU-first design means an attacker would need to acquire a large GPU farm, which is economically costly and visible. The ±1 bit difficulty cap prevents rapid hashrate manipulation.

7.2 Replay Protection

The chain_id field is included in every block header and validated on every P2P handshake. Transactions signed for one network are invalid on another.

7.3 Timestamp Manipulation

Block timestamps must not exceed the node's local time by more than 2 hours. This prevents difficulty manipulation via far-future timestamps.

7.4 Wallet Security

The txmwallet binary uses Argon2id key derivation and ChaCha20-Poly1305 authenticated encryption to protect private keys at rest. Private keys are never transmitted over the network. Users are responsible for backing up their encrypted wallet files.

7.5 Post-Mainnet Security Posture

• Mainnet (TensorHash v1) is live; soak testing ongoing since launch
• RPC is localhost-only by default; public RPC is reverse-proxied and rate-limited via nginx
• Pool treasury cold wallets are stored offline, separate from the seed node
• Risk disclosure, pool fee policy, and genesis parameters (zero premine) are publicly published
• External security audit planned for a future phase

8 Roadmap

— Disclaimer

This document is provided for informational purposes only. Tensorium is experimental software in active development. Mainnet is live — mining rewards are real TXM with real economic value. Participate only if you understand the risks.

The authors make no warranties regarding the software's fitness for any particular purpose, security properties, or continued availability. This software has not undergone a third-party security audit.

This is not financial advice. Participation in mainnet mining, bridging, or liquidity provision involves real risk. Always conduct your own research. See the full Risk Disclosure.