← All posts

The chain split at 1428771

Two blocks at height 1428771, one rule apart. The fork's 12.4.13 notes call an 8,005-byte OP_RETURN cap unchanged; v12.0.x nodes enforce 223 bytes in block validation, and the source for the change is unpublished.

At height 1428771 the Lotus chain split. Two blocks share the parent 000000000116fd10…. Lotusia’s is 00000000004111e1…, mined 21 November at 05:35 UTC. The fork’s is 0000000001eddaab…, mined 20 November at 23:54 UTC. The fork’s nodes accepted their block and built on it. A default v12.0.x node on Lotusia rejects it with scriptpubkey.

The cause is a single output: a 283-byte OP_RETURN script in the block’s second transaction, 4cb744eb…af4c. Lotusia caps that script at 223 bytes in block validation. The fork’s documentation allows 8,005. Nothing else about the block is wrong, and nothing about the split was announced, versioned, or given an activation time.

Which chain is which

We maintain the Lotus chain. The fork is a second chain that shares Lotusia’s history up to height 1428770; its releases live at LotusDevOrg/lotusd-releases, currently 12.5.3. The split is the first block where the two records differ.

This is not the separation the network has been preparing for. That one is scheduled for 1797886200, 21 December 2026, 20:50 UTC, when Lotusia’s 2nd Kings and the fork’s Napoleon activate at the same gate. Napoleon brings merged mining with SHA-256d and Scrypt, a coin-set commitment, and new contract opcodes. The split at 1428771 arrived a month early, with no activation time at all.

What was in the block

The first suspicion a rejected block invites is that the miner cheated. It did not. The coinbase pays normally: all fifteen outputs are standard under Lotusia’s rules, the height commitment and the miner-fund payment among them.

The failing output is vout[1] of the second transaction, 4cb744eb…af4c: 6a 4d 1701 followed by 279 bytes of text. It is a notice from a pool to one of its miners. A 12.4.16 node was syncing too slowly to catch up from scratch, and the miner should upgrade to 12.5.3 from a copy of a synced datadir. The script is standard under the fork’s rules and invalid under ours.

It is 60 bytes over Lotusia’s cap and 7,722 under the fork’s. A 223-byte version of the same notice would have been valid on both chains.

Relay policy versus block validity

Lotusia caps an OP_RETURN script at 223 bytes. The constant carries its own arithmetic:

/**
 * Default setting for nMaxDatacarrierBytes. 220 bytes of data, +1 for
 * OP_RETURN, +2 for the pushdata opcodes.
 */
static const unsigned int MAX_OP_RETURN_RELAY = 223;

ConnectBlock runs IsStandardTx on every transaction, coinbase included:

// Enforce standardness on all txs.
if (fRequireStandardConsensus) {
    std::string reason;
    if (!IsStandardTx(tx, fIsBareMultisigStd, CFeeRate(Amount::zero()),
                      reason)) {
        LogPrintf("ERROR: %s: contains a non-standard transaction "
                  "(and fRequireStandardConsensus is true)\n",
                  __func__);
        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                             reason);
    }
}

That check is on by default:

fRequireStandardPolicy = !args.GetBoolArg("-acceptnonstdtxn", false);
fRequireStandardConsensus = // defaults to fRequireStandardPolicy
    !args.GetBoolArg("-allownonstdtxnconsensus", !fRequireStandardPolicy);

An oversize script fails the datacarrier check:

unsigned nMaxDatacarrierBytes =
    gArgs.GetArg("-datacarriersize", MAX_OP_RETURN_RELAY);
if (scriptPubKey.size() > nMaxDatacarrierBytes) {
    return false;
}

IsStandardTx reports that failure as scriptpubkey:

if (!::IsStandard(txout.scriptPubKey, whichType)) {
    reason = "scriptpubkey";
    return false;
}

The distinction matters. A relay limit decides what a node passes to its peers. A block-validity rule decides what it accepts into the chain. The 223-byte cap is the second kind.

What the fork’s documentation says

The 12.4.13 release notes, published 16 November, are the earliest available note to give the 8,005 default, and they call it unchanged. Unchanged from what is not said. The same notes state that every node checks standardness on block transactions, always on for mainnet, the coinbase included. The fork’s protocol pages (blob, EMPP, ALP, SLP) call 8,005 bytes a relay limit.

Both cannot be true of a node that enforces IsStandardTx in ConnectBlock, and the ALP page goes further, saying a miner may include larger non-standard outputs. Either the fork’s block check uses a different bound than its pages describe, or its pages describe a consensus rule as policy. An operator on that chain cannot tell which.

The difference between 223 and 8,005 is not dated, not gated, and not named in any release note, blog post, upgrade page, or roadmap entry. The same notes warn that every LotusiaStewardship release, v12.0.0 included, splits at Napoleon; they never say it can split earlier, on this cap. The source for the change is not published: the 12.5.3 upgrade page says so in as many words. The fork’s protocol pages cite their source for the 8,005-byte limit, but that source is not published, so the citation cannot be read. The public givelotus/lotusd repository still carries 223 on all 40 branches.

The script is the only transaction in the fork’s blocks 1428771–1428889 with an OP_RETURN at or above 223 bytes, so this looks like one message rather than a systematic incompatibility: a deployment failure, not a protocol requirement. It was avoidable twice over. A shorter notice would have cleared both chains, and the rule that split them had no activation time attached.

What this means for operators

Lotusia’s rules are unchanged, and the 2nd Kings activation at 1797886200 proceeds as scheduled. Napoleon on the fork activates at the same gate, also as scheduled. The chains separate twice: once at 1428771, without an activation, and once at the gate, by design.

By the code path, passing -datacarriersize=8005 to a Lotusia node should connect the fork’s block. We have not tested it, and it would be a local consensus change, not a network fix. Following the fork past 1428771 means running the fork’s binary. A miner that wants its blocks valid on both records keeps its OP_RETURN scripts at 223 bytes.

A consensus event has requirements

A chain split is a consensus event. It should be announced, versioned, and given an activation time. This one was none of those.

The cap itself is not the problem; a chain may set it where it likes. The problem is a block-validity rule documented as relay policy, a cap called unchanged without saying from which version, and a split that arrived a month before the upgrade it was supposed to follow. The fix is cheap: one sentence naming the bound ConnectBlock applies and the file it lives in, a dated operator notice, and the commit that changed the default once the source is published on 21 December.

Check it yourself

  • lotus-cli getblockhash 1428771 returns Lotusia’s block, 00000000004111e1….
  • explorer.lotusia.org shows the fork’s block with confirmations: -1.
  • lotus-cli getblock 0000000001eddaab88f5eae7fb7064965162302ef57d62703c1b40f44d6066df 2 prints the 283-byte script. The fork’s block data is public too.
  • Feed the hex field of the raw transaction to lotus-cli testmempoolaccept and it returns allowed: false with reject-reason: scriptpubkey.
  • The cap is the 223-byte constant shown above, from the v12.0.2 tag. The rejecting node was v12.0.1, and v12.0.2 has no changes under src/validation.cpp, src/policy/, src/script/standard.h or src/init.cpp, so the result is the same.

The record is public. The rule should be too. Both blocks are there; check them.