Project Information

Objectives

• → Support any RAM generation — DDR2 through DDR5 and beyond
• → Be fully decentralized — no central authority, no pool required
• → Resist ASICs naturally via DRAM physics
• → Drive a new hardware upgrade cycle through epoch-based DAG growth
• → Maintain honest competition across all RAM generations
• → Create a new hardware market by Epoch 7 (1 TB RAM arrays)

Protocol Parameters

Network Architecture

┌──────────────────────────────────────────────┐
│           Full Nodes (Consensus)             │
│  Validate blocks · Store chain · REST API    │
│  polm.com.br/api/                            │
└──────────────┬───────────────────────────────┘
               │
        ┌──────┴──────────────┐
        ▼                     ▼
  Mining Clients         Polygon Oracle
  (CLI / GUI)            (ECDSA bridge)
        │                     │
DDR2·DDR3·DDR4·DDR5     ERC-20 POLM token
   Any RAM mines         polm.com.br/claim

PoLM Algorithm

Flow

1. Generate Memory DAG (256 MB in Epoch 0, seeded from epoch + prev_hash)
2. Initialize hash from: prev_hash + miner_address + nonce
3. Execute random memory walk (1,000 steps)
4. Measure average access latency (ns)
5. Compute score = 1.0 (fixed — telemetry only)
6. Validate: block_hash must start with "0" × difficulty

Memory Walk

h   = sha3_256(f"{prev_hash}:{address}:{nonce}".encode())
pos = int.from_bytes(h[:8], 'little') % dag_size

for step in range(100_000):
    mem = DAG[pos : pos+32]           # random DRAM read
    h   = sha3_256(h + mem)           # hash chain
    pos = int.from_bytes(h[:8], 'little') % dag_size

avg_latency = total_ns / 100_000
score       = 1.0 / avg_latency
final_hash  = h

Properties: Unpredictable access pattern (CPU prefetch cannot help) · Sequential dependency (cannot parallelize steps) · Cache-defeating (256 MB DAG > all L1/L2/L3) · Tamper-proof (latency embedded in block header)

Score Formula

Why this is fair

Difficulty Adjustment

expected_time = 144 × 120 = 17,280 seconds
actual_time   = Δt of last 144 blocks

ratio = clamp(0.75, 1.25, expected_time / actual_time)
D_new = D_old × ratio

Adjusts every 144 blocks. Maximum ±25% change per window prevents oscillation. Target: one block every 2 minutes.

Memory DAG

dag_seed = sha3_256("polm:" + str(epoch) + ":" + prev_hash[:32])
dag_size = 256 * (2 ** epoch)  # MB — doubles each epoch

The DAG doubles each epoch. This prevents caching across epochs and increases RAM requirements over time — the core mechanism driving hardware evolution.

Epoch Schedule

epoch  = height // 100_000
reward = 50.0 / (2 ** epoch)

⚡ Epoch 0 is the most accessible window. Any machine with 4 GB+ RAM — DDR2 to DDR5 — can mine today.

Block Validation Rules

A block is valid if ALL of the following hold:

1. block_hash starts with "0" × difficulty
2. block_hash == sha3_256(all_header_fields)
3. height == chain.tip.height + 1
4. prev_hash == chain.tip.block_hash
5. latency_ns >= 5  (anti-cache-exploit)
6. reward == 50.0 / (2 ** epoch)  (epoch halving enforced)
7. timestamp <= now + 120  (±2 min tolerance)
8. ram_size_mb >= MIN_RAM_MB[epoch]

Transactions

Transaction format

tx_id     = sha3_256(signing_bytes + signature)
signing   = "sender:receiver:amount:fee:timestamp:memo"
signature = ECDSA secp256k1

Transaction validation

1. amount > 0
2. fee >= 0.0001 POLM
3. sender.balance >= amount + fee
4. signature valid (ECDSA secp256k1)
5. not already confirmed
6. addresses start with "POLM"

Wallet Standard

Polygon Bridge & Oracle

1. Miner submits block → PoLM node validates
2. Oracle signs block data with ECDSA secp256k1
3. Oracle submits signed batch to Polygon smart contract
4. Miner claims ERC-20 POLM at polm.com.br/claim (fee: 0.5 MATIC)

Security Model

ASIC gap: DDR2 (~3800ns) vs DDR5 (~600ns) = ~6×. SHA-256 ASICs are 100,000× faster than CPUs. PoLM's physical constraint means custom silicon has no useful advantage.

Economics

Emission Schedule

Full supply takes 30+ years to mine completely. Emission is predictable and manipulation-resistant.

95% community mining · 5% founder (locked 5yr) · No pre-mine · No ICO · No VCs

Founder Allocation

Enforced at consensus level — no transaction from the founder address is valid before the lock expires:

if tx.sender == FOUNDER_ADDRESS:
    assert current_height >= GENESIS_HEIGHT + 5_256_000

REST API

Technology Stack

Miner Quick Start

🪟 Windows (PowerShell)

# Install Python 3.11
winget install Python.Python.3.11

# Download miner
mkdir $env:USERPROFILE\polm
Invoke-WebRequest -Uri "https://raw.githubusercontent.com/proof-of-legacy/Proof-of-Legacy-Memory/main/polm_miner_cli.py" -OutFile "$env:USERPROFILE\polm\miner.py"

# Run
python $env:USERPROFILE\polm\miner.py

🐧 Linux / macOS

curl -O https://raw.githubusercontent.com/proof-of-legacy/Proof-of-Legacy-Memory/main/polm_miner_cli.py
python3 polm_miner_cli.py

The miner auto-updates on every run. On first run: generates 12-word BIP-39 wallet, registers Polygon address, starts mining immediately.

Roadmap

• ✓v1.0 — PoLM algorithm designed and tested
• ✓v1.2 — Mainnet infrastructure · polm.com.br
• ✓v2.0 — Pure latency consensus · any RAM mines · epoch halving
• ✓CLI miner — no dependencies · Windows & Linux · auto-update (v1.5.4)
• ✓GUI miner — Windows / Linux / macOS
• ✓Oracle ECDSA — auto-sustaining Polygon bridge
• ✓Claim page — polm.com.br/claim
• ✓CPU / OS detection in explorer leaderboard
• ○Mining pool — for slow computers
• ○QuickSwap DEX listing (Polygon)
• ○CoinGecko / CoinMarketCap listing
• ○CEX listing
• ○Epoch 7 — 1 TB RAM mining arrays (new hardware market)

Conclusion

PoLM introduces a fundamentally new class of Proof-of-Work grounded in DRAM physics. By making latency — not compute power — the bottleneck:

• 01Any RAM mines — DDR2 through DDR5, all generations participate honestly
• 02No artificial rules — DAA LWMA · score = 1.0 fixed, nothing else
• 03ASIC-resistant by physics — DRAM latency cannot be engineered away
• 04Hardware evolution built-in — epochs force RAM upgrade cycles, creating a new industry by Epoch 7
• 05Truly decentralized — any PC with 4 GB+ RAM mines in Epoch 0
• 06Polygon bridge live — mine natively, claim ERC-20 POLM on Polygon

PoLM is experimental software. Not financial advice.