bnb-chain
diff --git a/‎cmd/jsutils/getchainstatus.js‎
Lines changed: 101 additions & 29 deletions b/‎cmd/jsutils/getchainstatus.js‎
Lines changed: 101 additions & 29 deletions
diff --git a/‎consensus/parlia/bid_block.go‎
Lines changed: 224 additions & 0 deletions b/‎consensus/parlia/bid_block.go‎
Lines changed: 224 additions & 0 deletions
@@ -290,6 +290,58 @@ const builderMap = new Map([
     ["0xA8caEc0D68a90Ac971EA1aDEFA1747447e1f9871",  "blockroute"],
 ]);
 
+function getMappedAddressName(addressMap, address) {
+    if (!address) return undefined;
+    try {
+        const normalized = ethers.getAddress(address);
+        return addressMap.get(normalized) || addressMap.get(normalized.toLowerCase());
+    } catch (_) {
+        return addressMap.get(address);
+    }
+}
+
+async function getBlockMevInfo(blockNumber) {
+    let rpcInfo;
+    try {
+        rpcInfo = await provider.send("eth_getBlockMevInfo", ["0x" + blockNumber.toString(16)]);
+        if (rpcInfo) {
+            if (!rpcInfo.builder) {
+                return { ...rpcInfo, source: "local" };
+            }
+            const source = rpcInfo.version === "v2" ? "bidblock" : "bid";
+            return { ...rpcInfo, source };
+        }
+    } catch (_) {
+        // Older validators do not expose eth_getBlockMevInfo; fall back to the
+        // pre-BEP-675 payment-tx heuristic below.
+    }
+
+    const block = await provider.getBlock(blockNumber);
+    if (!block) return rpcInfo || { blockNumber, source: "local" };
+
+    const txHashes = block.transactions.slice(-4);
+    const txResults = await Promise.all(txHashes.map(txHash => provider.getTransaction(txHash)));
+    for (const txData of txResults) {
+        if (!txData || !txData.to || !getMappedAddressName(builderMap, txData.to)) continue;
+        return {
+            blockNumber: block.number,
+            blockHash: block.hash,
+            miner: block.miner,
+            source: "bid",
+            builder: txData.to,
+            fallback: true,
+        };
+    }
+
+    return {
+        ...(rpcInfo || {}),
+        blockNumber: rpcInfo ? (rpcInfo.blockNumber || block.number) : block.number,
+        blockHash: rpcInfo ? (rpcInfo.blockHash || block.hash) : block.hash,
+        miner: rpcInfo ? (rpcInfo.miner || block.miner) : block.miner,
+        source: "local",
+    };
+}
+
 // 1.cmd: "GetMaxTxCountInBlockRange", usage:
 // node getchainstatus.js GetMaxTxCountInBlockRange --rpc https://bsc-testnet-dataseed.bnbchain.org \
 //      --startNum 40000001  --endNum 40000005 \
@@ -856,6 +908,8 @@ async function getMevStatus() {
         local: 0,
         ...Object.fromEntries([...new Set(builderMap.values())].map(builder => [builder, 0]))
     };
+    // Per-type tallies for the MEV path breakdown (v1 = legacy SendBid, v2 = bidblock).
+    let typeCounts = { mev_v1: 0, mev_v2: 0, local: 0 };
 
     // Get the latest block number
     const latestBlock = await provider.getBlockNumber();
@@ -877,12 +931,18 @@ async function getMevStatus() {
         return;
     }
 
-    const blockPromises = [];
+    const blockNumbers = [];
     for (let i = startBlock; i <= endBlock; i++) {
-        blockPromises.push(provider.getBlock(i));
+        blockNumbers.push(i);
     }
 
-    const blocks = await Promise.all(blockPromises);
+    let mevInfos;
+    try {
+        mevInfos = await Promise.all(blockNumbers.map(getBlockMevInfo));
+    } catch (err) {
+        console.error("GetMevStatus failed:", err.shortMessage || err.message || err);
+        return;
+    }
 
     // Calculate max lengths for alignment with default values
     let maxMinerLength = 10; // Default length
@@ -898,38 +958,39 @@ async function getMevStatus() {
         maxBuilderLength = Math.max(...builderLengths);
     }
 
-    for (const blockData of blocks) {
-        const minerInfo = validatorMap.get(blockData.miner);
+    for (const mevInfo of mevInfos) {
+        const blockNumber = typeof mevInfo.blockNumber === "string"
+            ? BigInt(mevInfo.blockNumber).toString()
+            : mevInfo.blockNumber.toString();
+        const minerInfo = getMappedAddressName(validatorMap, mevInfo.miner);
         const miner = minerInfo ? minerInfo[0] : "Unknown";
-        const transactions = blockData.transactions.slice(-4); // Last 4 transactions
-        const txPromises = transactions.map(txHash => provider.getTransaction(txHash));
-
-        const txResults = await Promise.all(txPromises);
-        let mevBlock = false;
-
-        for (const txData of txResults) {
-            if (builderMap.has(txData.to)) {
-                const builder = builderMap.get(txData.to);
-                counts[builder]++;
-
-                mevBlock = true;
-                console.log(
-                    `blockNum: ${blockData.number.toString().padStart(8)}      ` +
-                    `miner: ${miner.padEnd(maxMinerLength)}        ` +
-                    `builder: (${builder.padEnd(maxBuilderLength)}) ${txData.to}`
-                );
-                break;
-            }
-        }
 
-        if (!mevBlock) {
-            counts.local++;
+        if (mevInfo.source !== "local") {
+            const builderName = getMappedAddressName(builderMap, mevInfo.builder);
+            const friendlyName = builderName || mevInfo.builder;
+            const bucket = builderName || mevInfo.builder;
+            // v2 = bidblock (tagged), everything else on the MEV path = v1
+            // (tagged legacy bid, or heuristic-detected payBidTx which is v1-only).
+            const typeLabel = (mevInfo.source === "bidblock" || mevInfo.version === "v2") ? "mev_v2" : "mev_v1";
+            counts[bucket] = (counts[bucket] || 0) + 1;
+            typeCounts[typeLabel]++;
             console.log(
-                `blockNum: ${blockData.number.toString().padStart(8)}      ` +
+                `blockNum: ${blockNumber.padStart(8)}      ` +
+                `type: ${typeLabel.padEnd(6)}   ` +
                 `miner: ${miner.padEnd(maxMinerLength)}        ` +
-                `builder: local`
+                `builder: (${friendlyName.padEnd(maxBuilderLength)}) ${mevInfo.builder}`
             );
+            continue;
         }
+
+        counts.local++;
+        typeCounts.local++;
+        console.log(
+            `blockNum: ${blockNumber.padStart(8)}      ` +
+            `type: ${"local".padEnd(6)}   ` +
+            `miner: ${miner.padEnd(maxMinerLength)}        ` +
+            `builder: local`
+        );
     }
 
     const total = endBlock - startBlock + 1;
@@ -947,6 +1008,17 @@ async function getMevStatus() {
             const ratio = (value * 100 / total).toFixed(2);
             console.log(`${key.padEnd(maxBuilderLength)}: ${value.toString().padStart(3)} blocks (${ratio}%)`);
         });
+
+    // MEV path breakdown: v1 (legacy SendBid) vs v2 (bidblock), as a share of MEV blocks.
+    const mevTotal = typeCounts.mev_v1 + typeCounts.mev_v2;
+    console.log("\nMEV Path Distribution:");
+    console.log(`MEV blocks: ${mevTotal} (${(mevTotal * 100 / total).toFixed(2)}% of total)`);
+    if (mevTotal > 0) {
+        const v1Ratio = (typeCounts.mev_v1 * 100 / mevTotal).toFixed(2);
+        const v2Ratio = (typeCounts.mev_v2 * 100 / mevTotal).toFixed(2);
+        console.log(`${"mev_v1".padEnd(8)}: ${typeCounts.mev_v1.toString().padStart(3)} blocks (${v1Ratio}% of MEV)`);
+        console.log(`${"mev_v2".padEnd(8)}: ${typeCounts.mev_v2.toString().padStart(3)} blocks (${v2Ratio}% of MEV)`);
+    }
 }
 
 // 11.cmd: "getLargeTxs", usage:
 
@@ -0,0 +1,224 @@
+package parlia
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/consensus"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/systemcontracts"
+	"github.com/ethereum/go-ethereum/core/tracing"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+var signableSystemTxSelectors = map[string][4]byte{
+	"deposit":                  {0xf3, 0x40, 0xfa, 0x01},
+	"distributeFinalityReward": {0x30, 0x0c, 0x35, 0x67},
+	"updateValidatorSetV2":     {0x1e, 0x4c, 0x15, 0x24},
+}
+
+type expectedSystemTxEntry struct {
+	method   string
+	selector [4]byte
+}
+
+// PrepareForBidBlock is Prepare with Coinbase set to the in-turn validator instead of p.val.
+func (p *Parlia) PrepareForBidBlock(chain consensus.ChainHeaderReader, header *types.Header) error {
+	// Coinbase must be set before prepare(): backOffTime and calcDifficulty depend on it.
+	number := header.Number.Uint64()
+	snap, err := p.snapshot(chain, number-1, header.ParentHash, nil)
+	if err != nil {
+		return err
+	}
+	header.Coinbase = snap.inturnValidator()
+	return p.prepare(chain, header)
+}
+
+// FinalizeAndAssembleBidBlock assembles a BidBlock with unsigned system txs.
+func (p *Parlia) FinalizeAndAssembleBidBlock(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB,
+	body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks) (*types.Block, []*types.Receipt, error) {
+	block, receipts, err := p.finalizeAndAssemble(chain, header, state, body, receipts, tracer, systemTxPacking)
+	if err != nil {
+		return nil, nil, err
+	}
+	return block, receipts, nil
+}
+
+// SignSystemTx signs a BidBlock system tx with the validator key.
+func (p *Parlia) SignSystemTx(tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
+	p.lock.RLock()
+	defer p.lock.RUnlock()
+	if p.signTxFn == nil {
+		return nil, errors.New("signTxFn not set")
+	}
+	return p.signTxFn(accounts.Account{Address: p.val}, tx, chainID)
+}
+
+// isUnsignedSystemTxCandidate reports whether tx looks like an unsigned
+// BidBlock system tx. It does not recover the sender.
+func (p *Parlia) isUnsignedSystemTxCandidate(tx *types.Transaction) bool {
+	if tx == nil || tx.To() == nil || !isToSystemContract(*tx.To()) {
+		return false
+	}
+	if tx.GasPrice() == nil || tx.GasPrice().Sign() != 0 {
+		return false
+	}
+	v, r, s := tx.RawSignatureValues()
+	return isZeroSig(v, r, s)
+}
+
+// isSignableSystemTx reports whether tx can be bind-signed for BidBlock.
+func (p *Parlia) isSignableSystemTx(tx *types.Transaction) bool {
+	if !p.isUnsignedSystemTxCandidate(tx) {
+		return false
+	}
+	if *tx.To() != common.HexToAddress(systemcontracts.ValidatorContract) {
+		return false
+	}
+	return p.hasSignableSelector(tx.Data())
+}
+
+// expectedSystemTxShape returns the expected trailing system-tx order for accepted BidBlocks:
+//
+//	deposit -> distributeFinalityReward (cond.) -> updateValidatorSetV2 (cond.)
+//
+// Precondition: BidBlock admission has already enforced a non-zero deposit value.
+func (p *Parlia) expectedSystemTxShape(header, parent *types.Header) []expectedSystemTxEntry {
+	shape := make([]expectedSystemTxEntry, 0, 3)
+
+	shape = append(shape, expectedSystemTxEntry{
+		method:   "deposit",
+		selector: p.selectorFor("deposit"),
+	})
+
+	if header.Number.Uint64()%finalityRewardInterval == 0 {
+		shape = append(shape, expectedSystemTxEntry{
+			method:   "distributeFinalityReward",
+			selector: p.selectorFor("distributeFinalityReward"),
+		})
+	}
+
+	if isBreatheBlock(parent.Time, header.Time) {
+		shape = append(shape, expectedSystemTxEntry{
+			method:   "updateValidatorSetV2",
+			selector: p.selectorFor("updateValidatorSetV2"),
+		})
+	}
+
+	return shape
+}
+
+func (p *Parlia) verifySystemTxShape(txs []*types.Transaction, shape []expectedSystemTxEntry) error {
+	if len(txs) < len(shape) {
+		return fmt.Errorf("missing required system tx %q", shape[len(txs)].method)
+	}
+	if len(txs) > len(shape) {
+		return fmt.Errorf("unexpected extra system tx at position %d (selector 0x%x)",
+			len(shape), txSelector(txs[len(shape)]))
+	}
+	for i, exp := range shape {
+		if !bytes.HasPrefix(txs[i].Data(), exp.selector[:]) {
+			return fmt.Errorf("expected system tx %q at position %d, got selector 0x%x",
+				exp.method, i, txSelector(txs[i]))
+		}
+	}
+	return nil
+}
+
+// ExtractBidBlockDepositValue locates the trailing unsigned system-tx region and
+// returns its start index along with the value of the deposit tx (zero if absent).
+func (p *Parlia) ExtractBidBlockDepositValue(txs []*types.Transaction) (int, *big.Int) {
+	systemTxStart := len(txs)
+	for i := len(txs) - 1; i >= 0; i-- {
+		if !p.isUnsignedSystemTxCandidate(txs[i]) {
+			break
+		}
+		systemTxStart = i
+	}
+	// Deposit is the first trailing unsigned system tx (see expectedSystemTxShape).
+	// systemTxStart == 0 means there are no preceding user txs to collect fees from,
+	// which is invalid by design — return zero GasFee so admission rejects it.
+	if systemTxStart > 0 && systemTxStart < len(txs) {
+		depositSel := p.selectorFor("deposit")
+		if bytes.HasPrefix(txs[systemTxStart].Data(), depositSel[:]) {
+			return systemTxStart, new(big.Int).Set(txs[systemTxStart].Value())
+		}
+	}
+	return systemTxStart, new(big.Int)
+}
+
+// VerifyBidBlockSystemTxs validates the trailing unsigned system-tx region starting at systemTxStart.
+//
+//	Stage 1 — each trailing unsigned tx must be on the BEP-675 signable whitelist.
+//	Stage 2 — selectors & order must match expectedSystemTxShape for this header.
+func (p *Parlia) VerifyBidBlockSystemTxs(decoded *types.DecodedBidBlock, parent *types.Header, systemTxStart int) error {
+	for i := systemTxStart; i < len(decoded.Txs); i++ {
+		if !p.isSignableSystemTx(decoded.Txs[i]) {
+			toAddr := "<nil>"
+			if decoded.Txs[i].To() != nil {
+				toAddr = decoded.Txs[i].To().Hex()
+			}
+			return fmt.Errorf("unsigned system tx at position %d (to=%s) is not on the signable whitelist", i, toAddr)
+		}
+	}
+	shape := p.expectedSystemTxShape(decoded.Header, parent)
+	return p.verifySystemTxShape(decoded.Txs[systemTxStart:], shape)
+}
+
+func (p *Parlia) hasSignableSelector(data []byte) bool {
+	if len(data) < 4 {
+		return false
+	}
+	selector := data[:4]
+	for _, methodSelector := range signableSystemTxSelectors {
+		if bytes.Equal(selector, methodSelector[:]) {
+			return true
+		}
+	}
+	return false
+}
+
+func (p *Parlia) selectorFor(methodName string) [4]byte {
+	selector, ok := signableSystemTxSelectors[methodName]
+	if !ok {
+		panic(fmt.Sprintf("missing fixed system tx selector %s", methodName))
+	}
+	return selector
+}
+
+func (p *Parlia) BlockTimeUpperCheck(chain consensus.ChainHeaderReader, header *types.Header) error {
+	number := header.Number.Uint64()
+	snap, err := p.snapshot(chain, number-1, header.ParentHash, nil)
+	if err != nil {
+		return err
+	}
+
+	parent := chain.GetHeader(header.ParentHash, number-1)
+	if parent == nil {
+		return consensus.ErrUnknownAncestor
+	}
+
+	maxAllowed := p.blockTimeForRamanujanFork(snap, header, parent)
+	if header.MilliTimestamp() > maxAllowed {
+		return fmt.Errorf("BidBlock time too far in future: headerTime=%d, maxAllowed=%d",
+			header.MilliTimestamp(), maxAllowed)
+	}
+	return nil
+}
+
+func txSelector(tx *types.Transaction) []byte {
+	data := tx.Data()
+	if len(data) < 4 {
+		return data
+	}
+	return data[:4]
+}
+
+func isZeroSig(v, r, s *big.Int) bool {
+	isZero := func(x *big.Int) bool { return x == nil || x.Sign() == 0 }
+	return isZero(v) && isZero(r) && isZero(s)
+}