================================================================
 BigCoin Core (Windows x86-64)  v1.9
 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.9)

  v1.9 is a rebuild. The programs report v31.1.9, so the package
  version and the version the software reports agree again - v1.8 was
  a documentation release that shipped v1.7's binaries and reported
  v31.1.7.

  No consensus rule, activation height or default changed. A v1.9
  node and a v1.7 node accept exactly the same blocks.

  What changed is that an unconfigured node now finds the network.
  Until v1.8 no seed node was compiled into the binaries, so a node
  that never read bitcoin.conf never found a single peer - and
  copying that config file is exactly the step a newcomer can miss.
  The project's own seed node is now built in, and the 60-second wait
  that stood in front of it is gone: upstream Bitcoin Core only falls
  back to its built-in seeds after giving DNS seeds a minute to
  answer, and BigCoin has no DNS seeds for that minute to be worth
  anything.

  Measured on an empty data folder, with no config file, no -addnode
  and no -seednode:

                              v1.8     v1.9
      seeds loaded             +61 s     +0 s
      first peer connected     +61 s     +1 s

  In the v1.9 run the node went from the genesis block to the then
  current tip at height 19,694 in 84 seconds from launch. So
  unzipping this folder and starting the node is now enough. Copying
  bitcoin.conf is still worth doing - it is where your own settings
  go - but it is no longer what gets you onto the network.

  Two more things, both text rather than behaviour:

  - A new section below, ENCRYPTING THE WALLET. Everything in it was
    measured on this build on 2026-11-15, including the part that
    catches people out: encrypting a wallet generates a new HD seed,
    so a backup taken before encrypting does not cover the addresses
    you create afterwards.
  - The comment in src/kernel/chainparams.cpp that explains the
    yespower difficulty anchor still quoted 4,910 H/s and called the
    anchor "about twice" that rate. Measured on the same machine it
    is 8,250 H/s idle and about 5,300 H/s while the machine is being
    used for something else, which makes the anchor about 1.2x the
    idle rate. The anchor value itself is untouched - changing it
    would be a consensus change. The v1.8 runbook recorded this
    correction as required for the next source release; this is that
    release.


■ 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
                    (compiled into the v1.9 binaries, so a node needs
                     no config file to find the network)
  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 (optional from v1.9)
  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.
     From v1.9 the seed node is compiled in, so it finds the network
     on its own with no config file at all. Copying bitcoin.conf into
     that folder is still the tidy place for your own settings, and
     you can always add a peer by hand under
     Settings -> Options -> Network -> Add node.
  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. Optionally copy bitcoin.conf into it. From v1.9 you do not need
     to: the seed node is compiled into the binaries, so a node with
     no config file at all still finds the network. The file is where
     your own settings go.
  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
    A wallet backup is a bearer file. Anything that can read it can
    spend from it, unless the wallet was encrypted before the backup
    was taken - see ENCRYPTING THE WALLET below.
  - Stop the node with "stop", not by killing it:
      bigcoin-cli.exe -datadir=C:\BigCoin\data stop
    The node writes its databases on the way out, and a process that
    is killed instead can leave the block index needing a reindex on
    the next start.
    A normal Windows restart or shut down is fine on its own. Windows
    sends a console shutdown event, and the node's handler runs the
    same path as "stop"; measured on this build that takes about a
    second, which is inside the time Windows waits. What sends no
    such signal is Task Manager "End task", and a power cut.
  - 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.


■ ENCRYPTING THE WALLET

  A wallet file that is not encrypted is a bearer file: anything that
  can read it can spend from it. Encrypting it stores the private keys
  encrypted, so signing a transaction needs a passphrase.

  It is optional and it is not free. Read all three points first; the
  third is the one that costs people money.

  1. There is no way back. There is no "decryptwallet". The only route
     to an unencrypted wallet again is restoring a backup taken before
     you encrypted it.

  2. Lose the passphrase and the coins are gone. Not "gone until
     support resets it" - gone. Nobody holds a copy and nobody can
     recover it.

  3. Encrypting generates a NEW HD seed, so you need a NEW backup.
     The program says so itself when it finishes:

       wallet encrypted; The keypool has been flushed and a new HD
       seed was generated. You need to make a new backup with the
       backupwallet RPC.

     The old keys are not discarded - the descriptors holding them
     stay in the wallet, marked inactive, so the addresses you already
     have keep working and can still be signed for. But every address
     you get from now on comes from the new seed, and a backup taken
     before encrypting does not contain it. Measured on this build: a
     wallet with 8 descriptors and 4 keys became one with 16
     descriptors, 8 of them active, with all 4 original keys kept.

  So take two backups, and keep the second one:

      rem BEFORE. This one is only the escape hatch for a forgotten
      rem passphrase. It covers the addresses you have today and
      rem nothing later.
      bigcoin-cli.exe -datadir=C:\BigCoin\data -rpcwallet=miner ^
        backupwallet C:\somewhere\safe\before-encryption.dat

      rem Encrypt. Type the passphrase into the program, not onto the
      rem command line - see below.
      bigcoin-cli.exe -datadir=C:\BigCoin\data -rpcwallet=miner ^
        -stdin encryptwallet

      rem AFTER. From now on this is your real backup.
      bigcoin-cli.exe -datadir=C:\BigCoin\data -rpcwallet=miner ^
        backupwallet C:\somewhere\safe\after-encryption.dat

  With -stdin the program reads its remaining arguments from standard
  input, one per line: type the passphrase, press Enter, then press
  Ctrl+Z and Enter to end the input. Do not write it as
  "encryptwallet mypassphrase" instead. A command line is not private
  - any process on the machine can read another process's command
  line - and it stays in your console history as well.

  The GUI wallet does the whole thing in a dialog: bigcoin-qt.exe,
  then Settings -> Encrypt Wallet. It asks for the passphrase twice
  and never displays it. If you are not comfortable at a command
  prompt, use that, and take the new backup from the File menu
  afterwards.

  The node does not have to be restarted. The wallet stays loaded and
  encrypting takes about a second.

  WHAT STILL WORKS WHILE THE WALLET IS LOCKED

  Mining does. Measured on this build on 2026-11-15, with the wallet
  encrypted and locked:

      getnewaddress         works, and keeps working
      getaddressinfo        works
      getbalances           works
      getblocktemplate      works
      generatetoaddress     works
      submitblock           works
      sendtoaddress         fails with RPC error -13

  The rule behind that list is simple: a locked wallet can still do
  everything that needs only public keys, and nothing that has to
  sign. So signmessage and signrawtransactionwithwallet are in the
  same position as sendtoaddress - error -13 until you unlock.

  getnewaddress deserves its own sentence, because mine-bigcoin.cmd
  asks for one address per worker every time it starts. It keeps
  working indefinitely: the addresses are derived from the
  descriptor's public key, which is not encrypted, so the keypool
  refills while the wallet is locked. Tested with the keypool set to
  3 and 24 addresses requested in a row - no failures, and the pool
  never ran dry.

  So you can encrypt the wallet and carry on mining with it locked.
  Only spending needs the passphrase.

  TO SPEND

      rem unlock for 60 seconds, passphrase again read from standard
      rem input rather than the command line
      bigcoin-cli.exe -datadir=C:\BigCoin\data -rpcwallet=miner ^
        -stdinwalletpassphrase walletpassphrase 60

      rem ... send what you meant to send, then lock it again without
      rem waiting for the timeout
      bigcoin-cli.exe -datadir=C:\BigCoin\data -rpcwallet=miner ^
        walletlock

  Keep the window short. An unlocked wallet is an unencrypted wallet
  for as long as the timeout lasts. A wrong passphrase comes back as
  RPC error -14.


■ 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.9 (2026-11-15) Rebuild. No consensus rule, activation height or
                    default changed - a v1.9 node and a v1.7 node
                    accept exactly the same blocks.

                    The seed node is now compiled into the binaries,
                    and the 60-second wait for DNS seeds in front of
                    it is skipped on a chain that has no DNS seeds,
                    which BigCoin does not. An unconfigured node now
                    loads seeds at +0 s and has a peer at +1 s
                    instead of +61 s for both, so unzipping the
                    archive and starting the node is enough to join
                    the network.

                    Added ENCRYPTING THE WALLET to this readme, all
                    of it measured on this build: encrypting
                    generates a new HD seed and therefore needs a new
                    backup, there is no way to decrypt again, and
                    mining carries on with the wallet locked because
                    getnewaddress needs no private key.

                    Corrected the yespower anchor comment in
                    src/kernel/chainparams.cpp from 4,910 H/s and
                    "about twice that rate" to the measured 8,250 H/s
                    idle, about 5,300 H/s while the machine is in use
                    for something else, and an anchor about 1.2x the
                    idle rate. The anchor value itself is unchanged.

                    Numbering: the programs report v31.1.9. v1.8 was
                    a documentation release whose binaries were
                    v1.7's and reported v31.1.7, so 8 is skipped here
                    to put the package version and the reported
                    version back in step.
  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
  Mining status http://133.242.139.204/mining/status
  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).
================================================================
