================================================================
 BigCoin Core (Windows x86-64)  v1.8
 Author: Masashi Takamoto
 (A Japanese version of this file is included: README.ja.txt)
================================================================

BigCoin is an independent proof-of-work blockchain forked from
Bitcoin Core v31.1. It is not Bitcoin: different genesis block,
different network magic, different ports, different address format,
and no compatibility with the Bitcoin network in either direction.

No ICO. No premine sale. Nothing is for sale. The founder does not
sell BIG and there is no exchange or custody service behind this
project. Block 1 contains a 1,000,000 BIG founder reward, which is
visible on-chain and can be checked by anyone.


■ ABOUT THIS RELEASE (v1.8)

  v1.8 is a documentation release. The executables are byte-for-byte
  identical to the ones in v1.7 - nothing was recompiled, and no
  consensus rule, activation height or default changed. The programs
  still report themselves as v31.1.7, which is correct: that is the
  version of the code inside them.

  What changed is the text. Until v1.7 the Windows package shipped a
  README and a config file written in Japanese, which made the two
  files a newcomer has to read the only two files they could not
  read. Both are now English, with the Japanese kept as README.ja.txt
  and bitcoin.conf.ja. A stale figure in the explanation of the
  yespower switch was also corrected against measurement (see below).

  You can verify the claim about the binaries yourself: the SHA256 of
  every .exe and .dll in this archive matches the corresponding file
  in BigCoin-win64-v1.7.zip. Both archives stay available on the
  downloads page, and neither was replaced.


■ QUICK START (2 steps)

    1. Unzip this folder anywhere, for example C:\BigCoin
    2. Double-click mine-bigcoin.cmd

  That is all. The script starts a node, waits for the chain to sync,
  creates a wallet and mining addresses, and mines until you close
  the window. There is nothing to compile and nothing to install.

  If you want a wallet with a window instead of a miner, double-click
  bigcoin-qt.exe - see "THE GUI WALLET" below.


■ REQUIREMENTS

  - Windows 10 or 11, 64-bit
  - About 2 GB of free disk space to start with; the chain grows
  - From v1.7 mining also wants about 2 MiB of fast memory per worker
    thread, which is the point of the algorithm (see below). Any
    machine that can run a node has it.

  Everything needed is in this folder. The .dll files next to the
  executables and the platforms\ and styles\ folders are the Qt
  runtime for the GUI wallet; keep them where they are.

  Your antivirus may flag these files. Software that mines, opens
  network sockets and manages keys looks like the things antivirus
  vendors warn about, and every Bitcoin-derived wallet gets flagged
  sooner or later. If that happens, add the folder to your exclusion
  list - or do not, and build from the published source instead. The
  binaries are not code-signed: a code-signing certificate requires
  a verified legal identity, and this project is published
  anonymously, so there is no honest way to get one.


■ RUNNING ON A RENTED SERVER

  Check your provider's terms of service before you start mining.
  Many shared VPS hosts prohibit mining outright, while plans with
  dedicated resources often allow it. Running a node without mining
  is almost always fine. This is your responsibility, not ours.


★★ IMPORTANT (v1.7): THE PROOF-OF-WORK ALGORITHM CHANGES AT 19,500

  From block height 19,500 BigCoin's proof of work is yespower 1.0
  instead of double-SHA256. This is a hard fork. A node that has not
  upgraded rejects every block from that height onwards, and a miner
  that has not upgraded produces blocks nobody will accept.

  Watch the height, not the date:

      bigcoin-cli.exe -datadir=C:\BigCoin\data getblockcount

  and upgrade before you reach 19,500. The node will also tell you
  where the switch is and whether it has happened - look for
  pow_algo and yespower_activation_height in:

      bigcoin-cli.exe -datadir=C:\BigCoin\data getblockchaininfo

  Why: this chain's difficulty was 12.3 on 2026-11-12, which is
  roughly 88 MH/s of SHA-256 for the whole network. A single
  second-hand mining ASIC does tens of TH/s - more than a hundred
  thousand times that. Its owner could take every block, or rewrite
  recent history, for the price of the electricity, and nothing in a
  double-SHA256 chain this small can stop it. yespower needs 2 MiB of
  memory for every single hash, which no SHA-256 ASIC has, so that
  hardware cannot participate at all - its blocks are not
  uncompetitive, they are invalid. This is not a claim that BigCoin
  is ASIC-proof forever. It removes the attack that exists today, for
  the price of making mining slower in raw hashes per second for
  everybody equally.

  What changes for you as a miner:

  - Hashrate numbers drop from millions per second to a few hundred
    per second per core. That is expected and it is not a slowdown:
    difficulty is recalibrated at the switch, so blocks keep arriving
    at the same rate.
  - mine-bigcoin.cmd handles the switch by itself. It asks the node
    which algorithm the next block needs, so it cannot disagree with
    consensus about where the switch happens, and it resizes its own
    nonce budget when the era changes.
  - If you mine by hand with generatetoaddress, the nonce ceiling has
    to shrink by about four orders of magnitude. A yespower hash costs
    roughly 1 ms per core, so a budget of 20,000,000 would hold one
    RPC call open for hours. Use a few thousand and call it in a loop.
  - yespower is limited by memory bandwidth, not clock speed, so more
    worker threads do not always mean more hashes. On a measured
    8-core / 16-thread laptop one thread does 1,141 H/s while sixteen
    do 8,250 H/s in total - 516 H/s each, 45% of the single-thread
    figure. Try a smaller worker count and compare the hashes/s the
    script prints.

  Block identity does not change. The block hash shown by
  getblockhash and by the explorer is still double-SHA256 in both
  eras; what changed is only the value that gets compared against the
  target.


★ IMPORTANT (v1.7): STALL PROTECTION IS LIVE FROM HEIGHT 18,000

  The same release changes how ASERT measures elapsed time, from
  height 18,000:

      elapsed = max(parent's timestamp,
                    candidate's timestamp - 6 hours) - parent's timestamp

  Below six hours this is arithmetically identical to the old rule, so
  nothing about normal operation changes. Past six hours of silence
  the target starts easing on its own - halving every two days - so a
  difficulty left stranded by a miner who stopped clears itself
  instead of freezing the chain.

  Why it exists: at height 17,324 this chain sat still for 123 hours.
  Before this change the next block's target was fixed the moment its
  parent existed, and waiting did not make the block any easier to
  find, so the departure of one large miner left the difficulty above
  what the remaining hashrate could ever clear. Recovery took a manual
  hard fork. It should not need one a second time.

  Because the rule is a no-op below the grace period, height 18,000 is
  deliberately a height the chain has already passed: the blocks
  already mined above it validate byte-identically under both rules,
  so nothing is reorganized and no chain splits. That was verified by
  measurement before v1.7 was published - no gap at or above height
  18,000 comes close to six hours.

  What it costs: a miner who dates a block into the future gains at
  most a 2.9% discount on the target, bounded by the existing two-hour
  limit on future timestamps and available to everyone equally. There
  is no one-time step in difficulty at the activation height, because
  below six hours the two rules agree exactly.


★ IMPORTANT (v1.4 and later)

  At block height 17,325 the difficulty adjustment algorithm changed
  to ASERT. This is a hard fork and it has been live since
  2026-11-07. Nodes running v1.3 or older - including v1.3, which
  expected activation at 18,000 - reject every block from that height
  onwards, so you must run v1.4 or later.


■ CHAIN PARAMETERS

  Ticker            BIG (smallest unit: sat; max supply ~22,000,000)
  Genesis block     000086c5bc212db5bf8760b3fb3a30dfcd6af76257fd529814bc032c8134424d
  Genesis inscript. "BigCoin genesis 21/Oct/2026"
  Network magic     "BIGC" (0x42 0x49 0x47 0x43)
  P2P port          8338
  RPC port          8337
  Address format    big1... (bech32) / B... (base58, legacy)
  Block time        ~10 minutes, halving every 210,000 blocks
  Block reward      50 BIG
                    (block 1 only: 1,000,000 BIG founder reward,
                     verifiable on-chain by anyone)
  Proof of work     double-SHA256 up to height 19,499;
                    yespower 1.0 from 19,500
                    (N=2048, r=8, personalisation "BigCoin/yespower1.0",
                     over the 80-byte serialised header, 2 MiB per hash)
  Difficulty        ASERT (aserti3-2d), half-life 2 days, active from
                    height 17,325; from height 18,000 elapsed time is
                    measured to max(parent, candidate - 6 h), so the
                    target eases once the chain has been silent for
                    longer than six hours
  Pinned blocks     heights 1, 1000, 2000, 17000, 17750 - a reorg that
                    would change any of them is rejected regardless of
                    the attacker's hashrate
  Soft forks        BIP34/65/66, CSV, SegWit, Taproot - all active
                    from genesis
  Seed node         133.242.139.204:8338
  Explorer          http://133.242.139.204/


■ WHAT IS IN THIS ARCHIVE

  bigcoin-qt.exe    GUI wallet - start here if you are new
  bitcoind.exe      the node (headless, for servers)
  bigcoin-cli.exe   the command line client
  bitcoin.exe       multiprocess wrapper (you will not normally use it)
  mine-bigcoin.cmd  easy solo-mining script (double-click to mine)
  bitcoin.conf      config file template
  bitcoin.conf.ja   the same file with Japanese comments, for reading
  README.txt        this file
  README.ja.txt     the same document in Japanese
  *.dll, platforms\, styles\
                    the Qt runtime and libraries the programs need


■ THE GUI WALLET

  1. Put this folder wherever you like, for example C:\BigCoin
  2. Double-click bigcoin-qt.exe
  3. On first launch it asks where to keep its data. Choose a folder.
     Copy bitcoin.conf into that folder first and the wallet will
     find the seed node by itself. If you forget, you can add it
     later under Settings -> Options -> Network -> Add node, or paste
     133.242.139.204:8338 there.
  4. Once it has synced you can create a wallet, receive and send
     entirely in the window. Receiving addresses are on the Receive
     tab.

  You cannot run bitcoind.exe and bigcoin-qt.exe on the same data
  folder at the same time - pick one.


■ USING THE MINING SCRIPT

    mine-bigcoin.cmd        mine with (CPU cores - 1) workers
    mine-bigcoin.cmd 4      mine with exactly 4 workers

  Double-clicking it is the same as the first form. Close the window
  to stop mining; the node it started keeps running until you stop it
  with:

      bigcoin-cli.exe -datadir=data stop

  More workers means more hashrate under double-SHA256, but one core
  is left to the OS by default. Under yespower the best worker count
  is whatever your memory bandwidth allows, which is often fewer than
  the number of cores - compare the hashes/s line the script prints.

  The script is plain text and does nothing hidden - read it before
  you run it. Every command it issues is a local RPC call to the
  bitcoind.exe next to it, and the keys it creates never leave its
  own data folder.

  Four things worth knowing about how it works:

  1) Each worker mines to its own address.

     A generatetoaddress block template is fully determined by the
     previous block, the height, the coinbase output and nTime - and
     nTime only has one-second granularity. Two workers that start in
     the same second on the same address therefore grind a
     byte-identical block header in the identical nonce order, and
     one of them does no useful work whatsoever. Giving each worker
     its own address changes the coinbase, which changes the merkle
     root, which splits the search space for certain.

     The addresses are saved in data\mining-addresses.txt and all
     belong to the same 'miner' wallet, so the balances simply add up.

     Note that a count of mining addresses is NOT a count of miners.
     One person can hold any number of them.

  2) It raises rpcthreads automatically.

     generatetoaddress holds one RPC thread for the entire duration
     of the call. bitcoind only serves 4 threads by default, so
     without this change extra workers would just queue behind each
     other instead of mining in parallel. The script writes
     (workers + 4) into its data\bitcoin.conf.

     An existing config file belongs to you and is never rewritten -
     only completed. If a node was already running when you start the
     script, that node keeps using its old value; the script says so
     and shows you how to restart it.

  3) It sizes each call by measurement, not by assumption (new in
     v1.7).

     A yespower hash costs about 20,000 times a double-SHA256 hash, so
     a fixed nonce budget cannot be right for both eras. Each worker
     times its own calls and resizes its budget to land near 30
     seconds, which keeps calls short enough that a block found late
     in one is unlikely to be stale, on a slow dual-core box and on a
     64-core machine alike.

  4) It will mine on a stalled chain instead of waiting for it (new in
     v1.7).

     Older versions waited for the node to report that its initial
     block download had finished. A node only reports that once its
     own tip is less than a day old, and never re-reports it after
     that - which makes the flag a reliable "I have caught up" signal
     for a node that was already running, and a trap for one started
     while the chain itself is stalled. Anybody who had started the
     old script during the 123-hour freeze in November 2026 would
     have watched it print "synced up to block 17324" forever, and
     the chain would have been left without the one miner that could
     have ended the stall.

     This version also stops waiting when there is demonstrably
     nothing left to fetch: the block count has caught up with the
     header count, at least one peer agrees, and nothing has moved
     for a minute. Then it mines, because a stalled chain is exactly
     when it most needs a miner.


■ DOING IT BY HAND

  1. Put this folder somewhere, for example C:\BigCoin
  2. Make a data folder, for example C:\BigCoin\data
  3. Copy bitcoin.conf into it (the seed node is already in it)
  4. Start the node, from a Command Prompt in this folder:
       bitcoind.exe -datadir=C:\BigCoin\data
  5. From a second Command Prompt, check the state:
       bigcoin-cli.exe -datadir=C:\BigCoin\data getblockchaininfo
  6. Create a wallet:
       bigcoin-cli.exe -datadir=C:\BigCoin\data createwallet mywallet
  7. Get an address:
       bigcoin-cli.exe -datadir=C:\BigCoin\data getnewaddress
  8. Mine - and mind the last number, it is the nonce ceiling for one
     call and it depends on which algorithm is live:

       double-SHA256 (below height 19,500)
         bigcoin-cli.exe -datadir=C:\BigCoin\data ^
           generatetoaddress 1 <big1address> 20000000

       yespower (from height 19,500)
         bigcoin-cli.exe -datadir=C:\BigCoin\data ^
           generatetoaddress 1 <big1address> 4000

     Always pass it: the default (1,000,000) gives up almost
     immediately under double-SHA256, and would run for a long time
     under yespower. Do not make it enormous either - the call does
     not notice a new chain tip while it runs, so a worker would keep
     grinding a stale template after someone else found the block.
     If nothing is found the call returns an empty array [], so call
     it in a loop. mine-bigcoin.cmd does all of this for you.
  9. Check a balance and send:
       bigcoin-cli.exe -datadir=C:\BigCoin\data getbalance
       bigcoin-cli.exe -datadir=C:\BigCoin\data sendtoaddress <addr> <amount>
 10. Stop:
       bigcoin-cli.exe -datadir=C:\BigCoin\data stop


■ SECURITY AND BACKUPS

  - Your private keys live in the wallet file inside the data folder.
    Back it up with the RPC, not by copying the file while the node
    is running:
      bigcoin-cli.exe -datadir=C:\BigCoin\data -rpcwallet=miner ^
        backupwallet C:\path\to\backup.dat
  - Mining rewards become spendable after 100 confirmations, which is
    roughly one day.
  - NEVER expose RPC port 8337 to the internet. Forward only the P2P
    port 8338.
  - Opening port 8338 in the Windows firewall and on your router lets
    other nodes connect to you, which helps the network. It is
    optional, and it does publish your IP address to the peers you
    connect to - as any P2P client does.


■ BUILDING FROM SOURCE

  The complete source for these binaries is published, so you do not
  have to trust this archive:

    http://133.242.139.204/downloads
    git clone http://133.242.139.204/git/bigcoin.git

  Windows build instructions are in doc/build-windows-msvc.md inside
  the source archive. The Linux package ships a tested, exact build
  recipe in its own README.txt, including the toolchain versions.

  The yespower implementation lives in src/crypto/yespower and is the
  reference yespower 1.0 code, unmodified apart from the
  compatibility header that lets it compile as part of this tree. Its
  only BigCoin-specific input is the personalisation string, which is
  in src/pow.cpp next to the call. The Windows and Linux builds were
  checked against each other over 2,004 inputs and agree on every
  one, so the two platforms cannot split the chain at the switch.


■ CHANGELOG

  v1.8 (2026-11-12) Documentation release. The executables are
                    byte-identical to v1.7; no consensus rule,
                    activation height or default changed, and nothing
                    was recompiled.

                    README.txt and bitcoin.conf are now English, with
                    the Japanese split out into README.ja.txt and
                    bitcoin.conf.ja. Until v1.7 the two files a new
                    user has to read - the readme and the config file
                    they must copy for the node to find the network -
                    were the only two files in the package they could
                    not read unless they read Japanese.

                    Corrected a stale figure: the explanation of the
                    yespower switch said this chain's difficulty was
                    "around 2.3, roughly 40 MH/s". Measured on
                    2026-11-12 it was 12.3, roughly 88 MH/s. The
                    argument is unchanged - a single second-hand ASIC
                    is still more than a hundred thousand times the
                    whole chain - but the number now matches what the
                    node reports.

                    Added the measured yespower hashrate (1,141 H/s
                    on one thread, 8,250 H/s on sixteen, on an
                    8-core/16-thread laptop) in place of the earlier
                    vague "a few hundred per core".
  v1.7 (2026-11-09) Two consensus changes and a rewritten mining
                    script.

                    Proof of work becomes yespower 1.0 from height
                    19,500 (hard fork). Every hash needs 2 MiB of
                    memory, which excludes SHA-256 ASICs from the
                    chain entirely rather than merely outcompeting
                    them. Block identity stays double-SHA256.

                    From height 18,000, ASERT measures elapsed time to
                    max(parent's timestamp, candidate's timestamp
                    minus six hours) instead of the parent's timestamp
                    alone (hard fork). Below six hours the result is
                    byte-identical to the old rule, so normal
                    operation is unchanged; past six hours of silence
                    the target eases on its own and a difficulty
                    stranded by a departed miner no longer freezes the
                    chain, which is what cost 123 hours at height
                    17,324. Costs at most a 2.9% discount to a miner
                    who dates a block into the future, and no step at
                    the activation height.

                    Pinned block added at height 17,750, which caps
                    how far back a fork rooted in the remaining
                    double-SHA256 range could be mined.

                    mine-bigcoin.cmd now sizes its nonce budget by
                    measurement (required: a yespower hash is about
                    20,000 times a double-SHA256 hash), switches
                    algorithm by asking the node rather than by a
                    hardcoded height, and no longer waits forever on a
                    stalled chain. If you use the script, take this
                    version - the stall bug would have silenced every
                    script-driven miner for the whole duration of a
                    freeze longer than a day.

                    A v1.6 with the stall protection at height 22,000
                    was built and tested but never published; v1.7
                    supersedes it, and its activation heights are not
                    in any released binary.
  v1.5 (2026-11-07) Bundled the easy mining script mine-bigcoin.cmd.
                    Removed build-environment local folder path
                    strings that had been embedded in the shipped
                    binaries (no effect on behaviour). No consensus
                    changes - fully compatible with v1.4.
  v1.4 (2026-11-07) Moved the ASERT activation height forward from
                    18,000 to 17,325. Difficulty had been left high
                    after a large miner departed and block production
                    had stalled, so the fork was brought forward to
                    make difficulty follow immediately. The algorithm
                    itself is identical to v1.3.
  v1.3 (2026-11-02) Difficulty adjustment switched to ASERT
                    (aserti3-2d); originally to activate at 18,000,
                    moved to 17,325 in v1.4. Difficulty now follows
                    every block, so the chain recovers by itself after
                    a large miner leaves. This also fixed the v1.1
                    overflow workaround at the root. GUI currency unit
                    corrected from BTC to BIG.
  v1.2 (2026-11-01) Added the GUI wallet bigcoin-qt.exe. No consensus
                    changes - compatible with v1.0 and v1.1.
  v1.1 (2026-11-01) Fixed a header sync bug; pinned the early blocks.
  v1.0 (2026-11-01) First release.


■ LINKS

  Mining guide  http://133.242.139.204/mining
  Downloads     http://133.242.139.204/downloads
  Explorer      http://133.242.139.204/
  Source (git)  http://133.242.139.204/git/bigcoin.git
  Seed node     133.242.139.204:8338

  BigCoin has no monetary value and nothing here promises that it
  ever will. The developer does not sell, exchange or hold coins for
  anyone. Using, mining and holding BIG is entirely at your own risk.

  Licence: MIT, as inherited from Bitcoin Core.
  Copyright (c) 2026 Masashi Takamoto (the BigCoin changes)
  Copyright (c) 2009-2026 The Bitcoin Core developers (base)
  yespower 1.0 by Solar Designer, BSD-2-Clause / public domain as
  stated in its own headers (src/crypto/yespower).
================================================================
