[ANN][EMBR] 🔥 Emberchain — Keccak256 PoW | Proportional Pool

🔥 EMBERCHAIN (EMBR)
Mine from your browser. Share rewards proportionally. Shield your transactions. Trade peer-to-peer.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ WHAT IS EMBERCHAIN?

Emberchain (EMBR) is a mineable proof-of-work blockchain with a real EVM execution engine, a Monero-inspired shielded privacy pool, and a built-in peer-to-peer escrow exchange — all from a single browser-based wallet. No Rust node. No GPU drivers. Mine directly from the UI, or run a standalone script for maximum hash rate.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ CHAIN SPECIFICATIONS

Name	Emberchain
Ticker	EMBR
Algorithm	Keccak256 (CPU-friendly PoW)
Block Reward	5 EMBR per block
Target Block Time	8 seconds
Difficulty Adjustment	Every block — ±25% nudge toward 8s target
Supply	Fully mined — no premine, no ICO, no dev fund
Chain ID	7773 (0x1e5d)
Address Format	Standard 0x Ethereum-style (secp256k1)
EVM Compatible	Yes — real EthereumJS EVM (Cancun hardfork opcodes)
Smart Contracts	Fully supported — deploy and call from wallet UI

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ ADD TO METAMASK / EVM WALLET

Emberchain speaks standard Ethereum JSON-RPC. Any EVM wallet connects natively.

Code:

Network Name  : Emberchain
RPC URL       :  https://emberchain.org/api/rpc
Chain ID      : 7773
Currency      : EMBR
Block Explorer: https://emberchain.org/ledger

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ MINING — HOW IT WORKS

Algorithm: Keccak256 PoW

Find a nonce such that:

Code:

keccak256(JSON.stringify({ number, parentHash, timestamp, miner, difficulty, transactionsRoot, nonce })) ≤ target

Where target = (2^256 − 1) / difficulty. No SHA3 padding, no DAG, no VRAM — pure CPU work accessible to anyone with a browser or a script.

Field order matters — the JSON must be serialised in exactly the key order shown above. The Python script in this post handles this automatically.

Difficulty Retargeting

Adjusts every single block. Clamped at ±25% per block to prevent swings. The chain self-stabilizes around 8 seconds.

Three API calls is all it takes:

Code:

GET  /api/mining/template?minerAddress=0xYOUR_ADDRESS   → get work
POST /api/mining/share                                    → submit a partial share
POST /api/mining/submit                                   → submit a winning block

No stratum. No proprietary protocol. A complete external miner fits in under 50 lines.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ PROPORTIONAL SHARE-BASED PAYOUTS — LIVE

Block rewards are not winner-takes-all. Every miner who submitted a valid share during the round earns a cut proportional to their share count when the block lands — whether or not they found the winning nonce.

How shares work:

The template response includes two targets:

target — full block difficulty. Hit this and you win the block.
shareTarget — 64× easier (target × 64). Hit this and you bank a share.

At current difficulty you can expect roughly 64 shares per block on average. Every share earns you a fraction of the 5 EMBR block reward proportional to your contribution.

What this means in practice:

Small miners earn steadily rather than going long stretches with nothing
The miner who finds the winning block is automatically credited 1 share on top of any shares they already banked
No external pool operator — the pool lives inside the chain engine itself
No pool fee — 100% of the block reward goes to miners, split by shares
Payout breakdown for every block is visible in the block explorer
Share state and nonce deduplication survive server restarts — no gaming the restart

Share submission is handled automatically by the browser miner. External scripts just need to POST to /api/mining/share whenever a hash meets shareTarget.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ BROWSER MINING — ZERO SETUP

Open the wallet → click Mining → paste your address → click Start Mining. Your CPU starts hashing immediately in a background WebWorker.

Live stats shown:

Hash rate (H/s)
Shares submitted this round
Your estimated payout cut (%)
Blocks found this session
Running EMBR balance

No drivers. No software. Works on any desktop browser. Tab enforcement prevents double-mining from the same device.

Browser mining is the easiest way to start, but for maximum hash rate run the standalone script below — native C keccak256 is roughly 3–5× faster than JavaScript.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ EXTERNAL MINER — PYTHON SCRIPT (UNDER 50 LINES)

Native keccak256 via pycryptodome. Submits shares automatically. Faster than browser mining.

Code:

#!/usr/bin/env python3
"""Emberchain CPU miner with proportional share pool support."""
import json, time, random, requests
from Crypto.Hash import keccak

NODE   = "https://emberchain.org"
WALLET = "0xYOUR_EMBR_ADDRESS"   # ← only change this

def keccak256(data: bytes) -> int:
    k = keccak.new(digest_bits=256)
    k.update(data)
    return int.from_bytes(k.digest(), "big")

def encode(hdr: dict, nonce: int) -> bytes:
    return json.dumps({**hdr, "nonce": str(nonce)}, separators=(",", ":")).encode()

def mine():
    while True:
        t = requests.get(f"{NODE}/api/mining/template?minerAddress={WALLET}").json()
        block_target = int(t["target"])
        share_target = int(t["shareTarget"])
        hdr = t["header"]
        nonce, hashes, start = random.randint(0, 2**48), 0, time.time()

        while True:
            h = keccak256(encode(hdr, nonce))

            if h <= block_target:
                r = requests.post(f"{NODE}/api/mining/submit", json={
                    "minerAddress": WALLET, "header": hdr,
                    "nonce": str(nonce),
                    "blockHash": "0x" + h.to_bytes(32, "big").hex(),
                    "pendingTxHashes": t["pendingTxHashes"],
                })
                print(f"✓ Block #{hdr['number']}  status={r.status_code}")
                break

            if h <= share_target:
                requests.post(f"{NODE}/api/mining/share",
                    json={"minerAddress": WALLET, "header": hdr, "nonce": str(nonce)},
                    timeout=2)
                print(f"  share nonce={nonce}")

            nonce += 1; hashes += 1
            if hashes % 10_000 == 0:
                print(f"  {hashes/(time.time()-start):.0f} H/s  diff={hdr['difficulty']}")
                break  # refresh template each 10k hashes

if __name__ == "__main__":
    mine()

Install:

Code:

pip install requests pycryptodome

Tip: run multiple instances for multi-core mining. Each instance uses one CPU core. Each submits its own shares and earns its own proportional cut.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ PRIVACY — MONERO-STYLE SHIELDED POOL

Emberchain includes a full shielded transaction pool inspired by Monero's cryptographic primitives. Public EMBR can be shielded, transferred privately, and unshielded back — sender, recipient, and amount all hidden during the private leg.

Four cryptographic layers:

1. Stealth Addresses (ECDH one-time keys)
Each private note is sent to a one-time address derived from an ECDH shared secret. No two payments to the same recipient produce the same on-chain address. Only the recipient's spend key can find and claim the note.

2. Pedersen Commitments (amount hiding)
Amounts are never stored in plaintext. Each note carries C = v·G + r·H. The chain verifies inputs equal outputs + fee without learning any individual value.

3. LSAG Linkable Ring Signatures (sender anonymity)
Spending a note includes decoy unspent notes from the pool in an LSAG ring (same construction as Monero). Verifiers confirm one ring member authorized the spend without knowing which one.

4. Key Images (double-spend prevention)
Each spend produces a unique key image. The chain rejects any attempt to re-spend a note — without revealing which note the image corresponds to.

Honest limitations:

No Bulletproofs yet — amount non-negativity enforced by the node operator. ZK range proofs are on the roadmap.
Shield/unshield boundaries are visible (same design as Zcash t→z).
Anonymity set grows with usage — early rings are small, like early Monero.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ IN-APP P2P ESCROW EXCHANGE

Sellers lock EMBR into on-chain escrow and name a price. Buyers pay externally. The chain verifies the payment on-chain before releasing EMBR automatically — no intermediary, no KYC.

Supported payment currencies:

ETH — Ethereum mainnet (Etherscan, 12 confirmations)
USDT — ERC-20, TRC-20, BEP-20, Polygon (128 confirmations)
BTC — Bitcoin mainnet (Blockstream.info, 2 confirmations)
SOL — Solana mainnet (public RPC, finalized state)

Trade flow:

Seller creates listing — EMBR locked in escrow instantly
Buyer reserves listing — 15-minute exclusive window, enforced at chain level so two buyers can never race on the same listing
Buyer pays externally to seller's address
Buyer submits tx hash — chain fetches and verifies on the external explorer
EMBR released automatically on confirmation

Replay protection enforced at chain level — each external tx hash fulfills exactly one listing, forever.

Don't have crypto yet? A built-in on-ramp lets you purchase ETH, BTC, SOL, or USDT directly from the wallet interface before making your first trade.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ WALLET FEATURES

Create or import wallets — private key shown once, never stored server-side
Encrypted keystore file backup and restore
Send public EMBR transactions
Deploy EVM smart contracts from the browser
Shield EMBR → private pool / send privately / unshield back
Browser mining with live hash rate, share count, and estimated payout %
P2P exchange — list, reserve, buy, cancel with multi-chain payment verification
Built-in crypto on-ramp — buy ETH, BTC, SOL, or USDT without leaving the wallet
Full transaction and block explorer (with per-block payout breakdowns)
Price history chart from fulfilled exchange trades
MetaMask / EVM wallet connection via JSON-RPC

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ TECHNICAL STACK

Consensus: Custom Keccak256 PoW, per-block difficulty adjustment
EVM: EthereumJS — Cancun hardfork, full opcode support
Cryptography: ethereum-cryptography (secp256k1, keccak256), @noble/curves (privacy primitives)
State: EthereumJS SimpleStateManager, persisted as JSON + PostgreSQL backup
API: Express 5 REST + Ethereum JSON-RPC 2.0
Runtime: Node.js 24, TypeScript 5.9
Frontend: React + Vite + TanStack Query

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ COMPLETED

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

▌ NO PREMINE. NO ICO. NO DEV TAX.

Every EMBR in existence was mined. If you want some, run a miner.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Mining reports, hash rate benchmarks, share pool questions, and script modifications welcome below.