Nakamoto consensus powered by SHA256 proof-of-work

Mining is a specialized industry that uses purpose-built machines called mining rigs. These machines contain custom ASIC chips, and must be purchased specifically for crypto mining. Mining operations vary in scale from large industrial operations with full data-center warehouses with thousands of mining rigs, to hobbyists who run a small number of mining rigs at home.

Different cryptocurrencies may use different mining algorithms requiring different hardware. In the case of eCash, it uses the same SHA256 mining algorithm as Bitcoin, and thus BTC miners can also be used to mine eCash.

Once you have a mining rig set up, you have two options to start mining. You can point your hash power to a mining service provider, or you can set up infrastructure to mine on your own.

Using a mining service provider

Using a service provider has the advantage that it will handle technical setup for you, typically in exchange for a fee.

Running your own mining setup

Rather than relying on a service provider, a miner can take on the responsibility of handling their own technical setup. The advantage is that you retain privacy, and full control of the operation by not relying on a third party.

Miner fund

The coinbase transaction must include a "miner fund" output. This portion of the coinbase is dedicated to funding the development of eCash.

"coinbasetxn": {
    "minerfund": {
        "addresses": [
        "ecash:prfhcnyqnl5cgrnmlfmms675w93ld7mvvqd0y8lz07"
        ],
        "minimumvalue": 200000327
    }
}

The miner fund output is a payment of at least "coinbasetxn.minerfund.minimumvalue" (in Satoshi) to the eCash address "coinbasetxn.minerfund.addresses[0]". This amount should be subtracted from the total coinbase reward value.

Staking rewards

The coinbase transaction must include a "staking reward" output. This portion of the coinbase is going to a staker who is contributing to the security of the eCash network.

"coinbasetxn": {
    "stakingrewards": {
      "payoutscript": {
        "asm": "OP_DUP OP_HASH160 798038c8969512b74e82124a9a73641928932371 OP_EQUALVERIFY OP_CHECKSIG",
        "hex": "76a914798038c8969512b74e82124a9a7364192893237188ac",
        "reqSigs": 1,
        "type": "pubkeyhash",
        "addresses": [
          "ecash:qpucqwxgj6239d6wsgfy4xnnvsvj3yerwynur52mwp"
        ]
      },
      "minimumvalue": 62500102
    }
}

The staking reward output is a payment of at least "coinbasetxn.stakingrewards.minimumvalue" (in Satoshi) to the payout script "coinbasetxn.stakingrewards.payoutscript.hex". This amount should be subtracted from the total coinbase reward value.

Heartbeat

The eCash network will enforce Real Time Targeting (also known as Heartbeat) starting with the November 15, 2024 network upgrade. This feature increases the difficulty when blocks are found at a faster rate than the expected 10 minutes average interval. The difficulty monotonically decreases over time until it reaches a plateau value. This is intended to avoid spikes in the difficulty that can lead to inconsistent block intervals.

Blocks with a hash that is higher than the Real Time Target will be rejected by the Avalanche consensus layer.

"rtt": {
    "prevheadertime": [
      1727793391,
      1727790158,
      1727785595,
      1727781390
    ],
    "prevbits": "1d00ffff",
    "nodetime": 1727794761,
    "nexttarget": "1b0c2b8b"
}

Your pool software needs to make sure the submitted block hash complies with the Real Time Target. There are 2 options to achieve this:

• •Read the real time target from the block template. The value is directly available in compact form in the field "rtt.nexttarget". This field is updated at each call to "getblocktemplate".
• •Locally compute the target on the pool software. The formula is below:

uint32_t compute_next_target(gbt) {
    prevTarget = target_from_compact(gbt.rtt.prevbits);

    diffTime0 = max(1, now - gbt.rtt.prevheadertime[0]);
    target0 = prevTarget * 4.9192018423e-14 * (diffTime0 ** 5);

    diffTime1 = max(1, now - gbt.rtt.prevheadertime[1]);
    target1 = prevTarget * 4.8039080491e-17 * (diffTime1 ** 5);

    diffTime2 = max(1, now - gbt.rtt.prevheadertime[2]);
    target2 = prevTarget * 4.9192018423e-19 * (diffTime2 ** 5);

    diffTime3 = max(1, now - gbt.rtt.prevheadertime[3]);
    target3 = prevTarget * 4.6913164542e-20 * (diffTime3 ** 5);

    nextTarget = min(target0, target1, target2, target3);

    // The real time target is never higher (less difficult) than the normal
    // target.
    if (nextTarget < target_from_compact(gbt.bits)) {
        return target_to_compact(nextTarget);
    }
    
    return gbt.bits;
}