Mainnet Live

Proof of Memory.
Any RAM
mines.

PoLM is the first Proof-of-Work limited by DRAM latency. DDR2, DDR3, DDR4, DDR5 — every generation competes fairly. No ASICs. No GPUs. No shortcuts.

score = 1.0 (fixed — telemetry only) // Higher latency = higher score/step. Lower latency = more nonces/sec.

⛏ Start Mining 🔍 Explorer 📄 Whitepaper

Height

Block Reward

50 POLM

Epoch

0 / 8

Active Miners

21+

Top Miners · Live REAL-TIME

DDR2 i3-3240 · ~4200ns · Ubuntu

4.2 μs 50.00 POLM ✓

Established · Full reward since day 3

DDR3 i5-3210M · ~3900ns · Linux

3.9 μs 50.00 POLM ✓

Established · Full reward since day 2

DDR4 i5-14400F · ~905ns · Ubuntu

0.9 μs 50.00 POLM ↑

Established up · ~2 days to full reward

DDR5 Ryzen 9 9950X · ~865ns · Win11

0.87 μs 2.50 POLM ↑

New miner · Started today · ~4 days to full reward

📈

Block reward: Block reward halves each epoch (50 / 2^epoch). DAA LWMA adjusts difficulty automatically to maintain 120-second block time.

Epoch

Full Reward

50 POLM

DAG Size

256 MB

What is PoLM

A new kind of Proof-of-Work.

Most cryptocurrencies require purpose-built ASICs or powerful GPUs that render ordinary hardware obsolete within years. PoLM takes a fundamentally different approach.

The consensus score is derived purely from DRAM latency — a physical property of memory hardware that cannot be faked, virtualized, or miniaturized in silicon. DRAM latency variation between generations is ~8×. In SHA-256, ASICs are 100,000× faster than CPUs.

This means a 15-year-old DDR2 machine and a modern DDR5 workstation both compete honestly — not because of artificial boosts, but because physics rewards them differently.

♻️

Second life for e-waste Millions of DDR2 and DDR3 machines are discarded yearly. PoLM gives them economic purpose again — turning legacy hardware into mining infrastructure.

Property

SHA-256 / GPU PoW

PoLM

ASIC resistance

✗ ASIC 100,000× faster

✓ Physics-enforced

Old hardware

✗ Obsolete in 2-3 years

✓ DDR2 mines now

GPU advantage

✗ GDDR is dominant

✓ No GPU advantage

Consensus metric

Compute cycles

DRAM latency

Fairness model

Capital-intensive

Hardware-inclusive

DAG memory

Small / optional

256MB+ (epoch-scaled)

Pre-mine / ICO

✗ Common

✓ None

How it works

Four steps. Pure physics.

The algorithm is simple, auditable, and reproducible. No black boxes.

🧱

Build the Memory DAG

Each epoch generates a 256MB+ pseudorandom buffer from chain state. Every access is a real DRAM read — CPU cache is bypassed entirely. No shortcuts are possible.

🚶

Sequential Memory Walk

1,000 steps per nonce. Each step depends on the previous one — parallelization is impossible. The only bottleneck is the physical latency of your DRAM. Max 4 threads per miner.

📐

Physics Scores the Nonce

Score = 1.0 fixed. The network independently measures actual hardware latency. The reported RAM type is validated — it cannot be overridden or faked.

🔗

Network Validates

Peers verify the memory proof, hash target, latency plausibility, and timestamp. ECDSA signatures secure the oracle bridge to Polygon. Every claim is independently validated.

Any RAM Mines

Every generation has a natural place.

No artificial boosts. No penalties. The formula is the same for everyone — physics determines the outcome.

DDR2

~250 – 400 ns avg latency

High latency means high nonces per second. Every DDR2 access counts for more. PCs from 2004–2010 mine competitively today.

Core2Duo era · 2004–2010

Mining now

DDR3

~150 – 250 ns avg latency

Balanced latency profile. A well-tuned DDR3 machine delivers consistent scores. Mainstream 2010–2016 hardware participates fully.

Mainstream era · 2010–2016

Mining now

DDR4

~130 – 160 ns avg latency

Lower latency enables more nonces per second. More attempts compensate for lower score-per-step. Modern standard 2016–2022.

Modern standard · 2016–2022

Mining now

DDR5

~100 – 130 ns avg latency

Highest nonce throughput. Speed compensates for lower latency scores. Latest hardware 2022+ competes at maximum nonce rate.

Latest hardware · 2022+

Mining now

Epoch Evolution

Hardware cycles, by design.

Every 100,000 blocks (~138 days), the DAG doubles and the block reward halves. Each epoch creates demand for a new hardware tier — exactly like GPUs transformed Bitcoin mining.

Epoch	Blocks	Duration	DAG Size	Min RAM	Block Reward	Who mines?
0	0 – 100K	~138 days	256 MB	4 GB	50.000 POLM	Any PC with 4 GB+ RAM
● NOW 1	100K – 200K	~138 days	512 MB	8 GB	25.000 POLM	Most modern desktops
2	200K – 300K	~138 days	1 GB	32 GB	12.500 POLM	High-end workstations
3	300K – 400K	~138 days	2 GB	64 GB	6.250 POLM	Server-class machines
4	400K – 500K	~138 days	4 GB	128 GB	3.125 POLM	Dedicated RAM rigs
5	500K – 600K	~138 days	8 GB	256 GB	1.563 POLM	Enterprise RAM servers
6	600K – 700K	~138 days	16 GB	512 GB	0.781 POLM	RAM mining boards
⚡ 7	700K – 800K	~138 days	32 GB	1 TB	0.391 POLM	Industrial RAM arrays

Block reward formula: reward(epoch) = 50 / 2^epoch — consistent across all pages and the protocol backend.

Security Model

Built to resist. Physics enforces.

Every known attack vector considered and addressed in the protocol design.

🛡️

ASIC Attack

256MB+ DAG with latency-hard sequential walk. DRAM physics cannot be miniaturized or replicated in silicon at competitive cost.

✓ PHYSICS-ENFORCED

🖥️

GPU Mining

GDDR latency ≥ DDR latency. Memory bandwidth doesn't help — sequential access with 1K-step dependency chain prevents parallelism.

✓ NO ADVANTAGE

⚡

Cache Exploit

L3 Eviction forces real DRAM access is automatically rejected. CPU cache cannot pretend to be DRAM. The DAG at 256MB exceeds L3 cache on all consumer CPUs.

✓ AUTO-REJECTED

🔍

Fake RAM Type

Score measures real latency, not declared type. Hardware is auto-detected from the OS. Network validates latency plausibility independently.

✓ INDEPENDENTLY VALIDATED

🔐

Oracle Fraud

ECDSA signature required on every block registration. No valid oracle signature means no POLM minted on Polygon — period.

✓ ECDSA SIGNED

🔒

Founder Rug Pull

Founder's 10,500,000 POLM (5%) locked for 5,256,000 blocks (~5 years) in an immutable Polygon smart contract. Verifiable on-chain.

✓ ON-CHAIN LOCKED

Tokenomics

Fixed supply. Fair emission.

No pre-mine. No ICO. No VC allocation. Pure community mining from genesis.

Symbol POLM

Max Supply 210,000,000

Block Reward (Epoch 0) 50 POLM

Block Time Target 120 seconds

Halving Interval 100,000 blocks (~138d)

Score Formula 1.0 fixed

Hash Algorithm SHA3-256

Signatures ECDSA secp256k1

Wallet Standard BIP-39 / BIP-44

Max Threads / Miner 4

Pre-mine / ICO / VC None

Founder Allocation 10,500,000 (5%) · 5yr lock

ERC-20 Bridge Polygon Mainnet

Contract Address 0x7917...fdE55

Emission Schedule (POLM/block)

Epoch 0

50.000

Epoch 1

25.000

Epoch 2

12.500

Epoch 3

6.250

Epoch 4

3.125

Epoch 5

1.563

Epoch 6

0.781

Epoch 7

0.391

Formula

reward(epoch) = 50 / 2^epoch

Consistent across all protocol surfaces. No hardcoded exceptions.

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

For Miners

Start in minutes. Any machine.

No pool required. No registration. Mine directly against the network. RAM is auto-detected — it cannot be overridden.

🔑

WALLET SETUP — READ CAREFULLY

On first run, the miner will ask for two different addresses. Do not confuse them:

① POLM ADDRESS

Starts with POLM…

Generated automatically by the miner on first run. This is your mining identity on the PoLM network.

✓ Auto-generated · Keep it safe

② POLYGON ADDRESS

Starts with 0x…

Your MetaMask or Trust Wallet address on Polygon. This is where you receive POLM tokens after claiming.

✓ MetaMask / Trust Wallet

❌ Don't put 0x… in the POLM field

❌ Don't put POLM… in the Polygon field

🪟

Windows

PowerShell · No antivirus issues

⭐ EASIEST

Install Python 3.11 from python.org — check "Add Python to PATH"

Open PowerShell and run these commands in order:

            # 1. Create folder

            mkdir $env:USERPROFILE\polm

            # 2. Enter the folder (REQUIRED)

            cd $env:USERPROFILE\polm

            # 3. Download miner

            Invoke-WebRequest -Uri "https://raw.githubusercontent.com/proof-of-legacy/Proof-of-Legacy-Memory/main/polm_miner_cli.py" -OutFile "miner.py"

            # 4. Run

            python miner.py

🚨 DO NOT run like this:

python $env:USERPROFILE\polm\miner.py

Running from System32 causes permission errors. Always cd into the folder first, then run python miner.py.

The miner will generate your POLM address automatically.
Then enter your Polygon wallet (0x…) to receive rewards.
Mining starts automatically ⛏

🐧

Linux / macOS

GUI or command line

Clone and install dependencies:

            git clone https://github.com/proof-of-legacy/Proof-of-Legacy-Memory.git

            cd Proof-of-Legacy-Memory

            python3 -m venv venv

            source venv/bin/activate

            pip install -r requirements.txt

Run the miner:

            # GUI miner (recommended)

            python3 polm_miner_gui.py

            # Command line

            python3 polm_miner_cli.py

On first run: your POLM address is generated automatically (12-word BIP-39 wallet).
Enter your Polygon wallet (0x…) to receive rewards.
When a block is found you'll see ACCEPTED 🎉

💰

Claiming your POLM on Polygon

After mining, claim your POLM as an ERC-20 token on Polygon Mainnet via polm.com.br/claim. Requires Chrome, Firefox or Brave + MetaMask. Claim fee: 0.5 MATIC. Contract verified on Sourcify + Blockscout.

For Developers & Exchanges

Open API. No authentication required.

Full node API available at polm.com.br/api/ — MIT licensed, open source.

GET

/api/

Network summary — height, difficulty, supply, peers, reward

GET

/api/chain?limit=N&offset=O

Paginated block list with full block data

GET

/api/block/{height}

Single block by height — hash, miner, RAM, latency, score, reward

GET

/api/miners

Active miners leaderboard with blocks, POLM earned, hardware

GET

/api/balance/{address}

POLM balance for a given miner address

GET

/api/getwork

Current mining work — for custom miner implementations

GET /api/ — Network Summary Response

{
  "height": 35764,
  "difficulty": 5,
  "epoch": 0,
  "block_time": 120,
  "next_reward": 50.0,
  "total_supply": 1695400.0,
  "max_supply": 210000000,
  "dag_size_mb": 256,
  "peers": 1,
  "symbol": "POLM",
  "network": "mainnet",
  "version": "2.0.0",
  "score_formula": "1.0 fixed",
  "halving_interval": 100000,
  "founder_lock": 5256000
}

Exchange Integration

Symbol: POLM · Decimals: 8 · Block time: 120s · Recommended confirmations: 6 · Node API: polm.com.br/api/
ERC-20 on Polygon: 0x79175931C54c9765E5846229a0eB118ef24fdE55

Decentralization

Run a Full Node.

Anyone can run a PoLM full node. No permission needed. The network grows stronger with every new node — just like Bitcoin.

🌐

What your node does

✓ Stores a full copy of the PoLM blockchain
✓ Validates all blocks and transactions independently
✓ Propagates new blocks to the rest of the network
✓ Syncs the full chain from polm.com.br on startup
✓ Can also mine — node + miner in one process

⚙️

Requirements

→ Python 3.10+ installed
→ 4 GB RAM minimum (any type — DDR2 to DDR5)
→ ~500 MB disk for the full chain (Epoch 0)
→ Port 6060 open (for P2P connections)
→ Stable internet connection

🐧 Linux / macOS — Run a full node

# 1. Clone the repository
git clone https://github.com/proof-of-legacy/Proof-of-Legacy-Memory.git
cd Proof-of-Legacy-Memory

# 2. Install dependencies
python3 -m venv venv && source venv/bin/activate
pip install -r requirements.txt

# 3. Start the full node (auto-syncs from the network)
python3 polm.py node 6060

# 4. (Optional) Mine while running a node
python3 polm.py node 6060 --mine

🪟 Windows — Run a full node

# In PowerShell:
git clone https://github.com/proof-of-legacy/Proof-of-Legacy-Memory.git
cd Proof-of-Legacy-Memory
python -m venv venv; .\venv\Scripts\Activate.ps1
pip install -r requirements.txt

python polm.py node 6060

⚡

WHAT HAPPENS WHEN YOUR NODE STARTS

Your node connects to polm.com.br, downloads the full blockchain and keeps itself in sync. No configuration needed.

Current state: PoLM runs a single validating node, operated by the project. Running your own gives you an independent, verifiable copy of the chain — peer-to-peer propagation between nodes is the next step on the roadmap.

Community