I developed a P2P attempt to connect to erigon bsc using nodejs, but it failed. I don't know why?

[qq4578730]

Please help me
I developed a P2P attempt to connect to erigon bsc using nodejs, but it failed. I don't know why?
The connection was successful, but the peer will not relay blocks and transactions.
Normal connection geth.

import { randomBytes } from 'crypto'
import { Block, BlockHeader } from '@ethereumjs/block'
import { Common } from '@ethereumjs/common'
import { RLP } from '@ethereumjs/rlp'
import pkg from '@ethereumjs/tx'
const { TransactionFactory, TypedTransaction } = pkg;
import { arrToBufArr,bufArrToArr } from '@ethereumjs/util'
import chalk from 'chalk'
import LRUCache from 'lru-cache'
import ms from 'ms'

import * as devp2p from '@ethereumjs/devp2p'



const PRIVATE_KEY = randomBytes(32)
const common = new Common({
    "chain": {
        "name": "mainnet",
        "chainId": 56,
        "networkId": 56,
        "defaultHardfork": "istanbul",
        "consensus": {
            "type": "poa",
            "algorithm": "clique",
            "clique": {
                "period": 3,
                "epoch": 200
            }
        },
        "comment": "The Ethereum main chain",
        "url": "https://ethstats.net/",
        "genesis": {
            "hash": "0x0d21840abff46b96c84b2ac9e10e4f5cdaeb5693cb665db62a2f3b02d2d57b5b",
            "timestamp": null,
            "gasLimit": 40000000,
            "difficulty": 1,
            "nonce": "0x0000000000000000",
            "extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
            "stateRoot": "0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544"
        },
        "hardforks": [
            {
                "name": "istanbul",
                "block": 0,
                "forkHash": "0xf98d1072"
            }
        ],
        "bootstrapNodes": [
            {
                "ip": "52.71.43.172",
                "port": 30311,
                "id": "1cc4534b14cfe351ab740a1418ab944a234ca2f702915eadb7e558a02010cb7c5a8c295a3b56bcefa7701c07752acd5539cb13df2aab8ae2d98934d712611443",
                "location": "ap-southeast-1-001",
                "comment": "bootnode-aws-ap-southeast-1-001"
            },
            {
                "ip": "34.246.65.14",
                "port": 30311,
                "id": "28b1d16562dac280dacaaf45d54516b85bc6c994252a9825c5cc4e080d3e53446d05f63ba495ea7d44d6c316b54cd92b245c5c328c37da24605c4a93a0d099c4",
                "location": "us-east-1-001",
                "comment": "bootnode-aws-us-east-1-001"
            },
            {
                "ip": "35.73.137.11",
                "port": 30311,
                "id": "5a7b996048d1b0a07683a949662c87c09b55247ce774aeee10bb886892e586e3c604564393292e38ef43c023ee9981e1f8b335766ec4f0f256e57f8640b079d5",
                "location": "eu-west-1-001",
                "comment": "bootnode-aws-eu-west-1-001"
            }
        ],
        "dnsNetworks": [
            "enrtree://AKA3AM6LPBYEUDMVNU3BSVQJ5AD45Y7YPOHJLEF6W26QOE4VTUDPE@all.mainnet.ethdisco.net"
        ]
    }
})

// const bootstrapNodes = [{
//     ip: '3.93.194.0',
//     port: 30311
// },{
//     ip: '3.72.89.216',
//     port: 30311
// },{
//     ip: '3.239.197.183',
//     port: 30311
// },{
//     ip: '51.81.93.133',
//     port: 30311
// },{
//     ip: '23.88.74.94',
//     port: 30311
// },{
//     ip: '141.148.42.11',
//     port: 30311
// },{
//     ip: '34.200.214.135',
//     port: 30311
// }]
//Geth/v1.1.18/linux-amd64/go1.18.3

// const bootstrapNodes = [{
//     ip: '18.183.93.121',
//     port: 33311
// },{
//     ip: '54.95.18.73',
//     port: 33311
// }]

const bootstrapNodes = [{
    ip: '95.216.89.204',
    port: 30408	
}]

const BOOTNODES = bootstrapNodes.map((node) => {
    return {
        address: node.ip,
        udpPort: node.port,
        tcpPort: node.port,
    }
})

const CHECK_BLOCK_TITLE = 'Berlin Fork' // Only for debugging/console output
const CHECK_BLOCK_NR = 26478593 //Block
const CHECK_BLOCK = 'a62b4dbcc33cb50a4d117799021f0d9f63fa9d00fccd325cfe48630aded4752e'//hash
const CHECK_BLOCK_HEADER = arrToBufArr(
    RLP.decode(
        '0xf9025fa03b3bf511bddac8597638c1d0f055df5be7028a20e7b66adc5d98beedc1e2a4d2a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347947ae2f5b9e386cd1b50a4550696d957cb4900f03aa0ef0dcabb6b02e64095aa63ebaa44c86dc50b7f1dc1d75795e9b2b3e6100a2224a040730247d4144c296b29c841f9ce148611f4431467e4e2a47834e28369685993a05dd023ca4ffc4b0eb063c84924d5c653aa8b377a1eca2f345a1080484ed542b1b90100a0300a104b097c15d66a30c0b3120809a9d5221e8900786130160268dc80891cfe80014042d1d18013f18da4205c005a0091921ccc095802800e040c88240359168abe700108d82009a0027aa100eaa83816012144640cc388041210a43c9b34c4b83361020600aa4051a8c2ac008c601e2850f795a8ec8260a1b512188387c1288cfa0104044c05a9c9560208495e1046240c65dda6010a6904484658920f28aee0258b0190021217c93c430a860d4d322680c082805121a863226867a1c050a4986ec63b8913c7406392694122920738045320278c09181001c74e1068f2cd82d820054024e1c901b44e01568043068032b4481462c44b7a1513203921c0090284019408018408583b0084013179568464115e8cb861d883010113846765746888676f312e31392e35856c696e75780000005b7663b5cb4fafeff1ea4f252b71c96dff7956717a75a700828547be70de42c1e0d03a2a231fa9e60ce0c0bd05b1bec3f66e3909a20ce4490990fd919d39f64499bc84d400a00000000000000000000000000000000000000000000000000000000000000000880000000000000000'
    )
)

const getPeerAddr = (peer) => `${peer._socket.remoteAddress}:${peer._socket.remotePort}`

// DPT
const dpt = new devp2p.DPT(PRIVATE_KEY, {
    refreshInterval: 30000,
    endpoint: {
        address: '0.0.0.0',
        udpPort: null,
        tcpPort: null,
    },
})

/* eslint-disable no-console */
dpt.on('error', (err) => {
    //console.error(chalk.red(`DPT error: ${err}`))
})

/* eslint-disable @typescript-eslint/no-use-before-define */
const REMOTE_CLIENTID_FILTER = [
    "Geth",
    "ronin",
    "bor",
    "OpenEthereum",
    "Nethermind",
    "Grails",
    "Gubiq",
]
// RLPx
const rlpx = new devp2p.RLPx(PRIVATE_KEY, {
    dpt,
    timeout:1000*360,
    maxPeers: 1,
    clientId:"Geth/v1.1.18/linux-amd64/go1.18.3",
    capabilities: [devp2p.ETH.eth66],
    common,
    //remoteClientIdFilter: REMOTE_CLIENTID_FILTER,
})

rlpx.on('error', (err) => console.error(chalk.red(`RLPx error: ${err.stack ?? err}`)))
rlpx.on('peer:new', (peer) => {
    console.log("peer:new")
})

rlpx.on('peer:added', (peer) => {
    const addr = getPeerAddr(peer)
    const eth = peer.getProtocols()[0]
    const requests = { headers: [], bodies: [], msgTypes: {}, receipts:[] }
    console.log(peer.getHelloMessage())
    const clientId = peer.getHelloMessage().clientId
    // console.log(
    //     chalk.green(
    //         `Add peer: ${addr} ${clientId} (eth${eth.getVersion()}) (total: ${rlpx.getPeers().length})`
    //     )
    // )

    eth.sendStatus({
        td: Buffer.from('0322f9d9','hex'),
        bestHash: Buffer.from(
            'a62b4dbcc33cb50a4d117799021f0d9f63fa9d00fccd325cfe48630aded4752e',
            'hex'
        ),
        genesisHash: Buffer.from(
            '0d21840abff46b96c84b2ac9e10e4f5cdaeb5693cb665db62a2f3b02d2d57b5b',
            'hex'
        ),
    })
    let forkVerified = false
    let forkDrop;
    eth.once('status', () => {
        eth.sendMessage(devp2p.ETH.MESSAGE_CODES.GET_BLOCK_HEADERS, [
            Buffer.from([22]),
            [Buffer.from(CHECK_BLOCK,"hex"), Buffer.from([1]), Buffer.from([]), Buffer.from([])],
        ])
        forkDrop = setTimeout(() => {
            console.log(`主动关闭   ${addr}`)
            peer.disconnect(devp2p.DISCONNECT_REASONS.USELESS_PEER)
        }, ms('30s'))
        peer.once('close', () => {
            if (forkVerified){
                console.log(`关闭   ${addr}`)
            }
            clearTimeout(forkDrop)
        })
    })

    eth.on('message', async (code, payload) => {
        if (code in devp2p.ETH.MESSAGE_CODES) {
            requests.msgTypes[code] = code + 1
        } else {
            requests.msgTypes[code] = 1
        }
        switch (code) {
            case devp2p.ETH.MESSAGE_CODES.STATUS:
                if(devp2p.buffer2int(payload[1]) === 56){
                    console.log(`STATUS   ${addr}`, payload)
                }else{
                    peer.disconnect(devp2p.DISCONNECT_REASONS.USELESS_PEER)
                }
            case devp2p.ETH.MESSAGE_CODES.NEW_BLOCK_HASHES:
                if (!forkVerified) break
                for (const item of payload) {
                    const [blockHash,blockNumber] = item
                    const blockHashHex = blockHash.toString('hex')
                    if (blocksCache.has(blockHashHex)){
                        continue;
                    }
                    blocksCache.set(blockHashHex, true)
                    requests.headers.push(blockHash)
                    console.log(`NEW_BLOCK_HASHES   ${addr}`,devp2p.buffer2int(blockNumber))
                    setTimeout(() => {
                        eth.sendMessage(devp2p.ETH.MESSAGE_CODES.GET_BLOCK_HEADERS, [
                            Buffer.from([2]),
                            [blockHash, Buffer.from([1]), Buffer.from([]), Buffer.from([])],
                        ])
                    }, ms('0.1s'))
                }
                break

            case devp2p.ETH.MESSAGE_CODES.TX:
                if (!forkVerified) break
                
                for (const item of payload) {
                    onNewTx(item, peer)
                }

                break
            case devp2p.ETH.MESSAGE_CODES.NEW_POOLED_TRANSACTION_HASHES:
                // if (!forkVerified) break
                console.log(`NEW_POOLED_TRANSACTION_HASHES   ${addr}`)
                // setTimeout(() => {
                //     eth.sendMessage(devp2p.ETH.MESSAGE_CODES.GET_POOLED_TRANSACTIONS, [
                //         Buffer.from([2]),
                //         payload,
                //     ])
                // }, ms('0.1s'))
                break
            case devp2p.ETH.MESSAGE_CODES.POOLED_TRANSACTIONS:
                if (!forkVerified) break
                console.log(`POOLED_TRANSACTIONS   ${addr}`)
                for(var tx of payload[1]){
                    //console.log(tx)
                }
                break
            case devp2p.ETH.MESSAGE_CODES.GET_BLOCK_HEADERS: {
                console.log(`GET_BLOCK_HEADERS ${addr}`,devp2p.buffer2int(payload[1][0]),payload[1][0])
                const headers = []
                // hack
                //console.log(payload[1][0].toString('hex'))
                if(payload[1][0].toString('hex') === CHECK_BLOCK){
                    headers.push(CHECK_BLOCK_HEADER)
                }else if (devp2p.buffer2int(payload[1][0]) === CHECK_BLOCK_NR) {
                    headers.push(CHECK_BLOCK_HEADER)
                }

                if (requests.headers.length === 0 && requests.msgTypes[code] >= 8) {
                    peer.disconnect(devp2p.DISCONNECT_REASONS.USELESS_PEER)
                } else {
                    eth.sendMessage(devp2p.ETH.MESSAGE_CODES.BLOCK_HEADERS, [payload[0], headers])
                }
                break
            }

            case devp2p.ETH.MESSAGE_CODES.BLOCK_HEADERS: {
                console.log("BLOCK_HEADERS")
                if(!payload[1][0]){
                    break
                }
                if (!forkVerified) {
                    if (payload[1].length !== 1) {
                        // console.log(
                        //     `${addr} 应为一个标头 ${CHECK_BLOCK_TITLE} 验证（收到: ${payload[1].length})`
                        // )
                        // peer.disconnect(devp2p.DISCONNECT_REASONS.USELESS_PEER)
                        eth.sendMessage(devp2p.ETH.MESSAGE_CODES.BLOCK_HEADERS, [payload[0], []])
                        break
                    }
                    if(payload[1][0] && payload[1][0].length >= 15 && payload[1][0].length < 17){
                        const header = BlockHeader.fromValuesArray(payload[1][0],{ common })
                        // console.log(header.number)
                        // console.log(Buffer.from(RLP.encode(bufArrToArr(payload[1][0]))).toString("hex"))
                        const expectedHash = CHECK_BLOCK
                        console.log(header.hash().toString("hex")," | ",expectedHash)
                        if (header.hash().toString("hex") === expectedHash) {
                            console.log(`${addr} 经验证位于 ${CHECK_BLOCK_TITLE}`)
                            forkVerified = true
                        }
                    }
                } else {
                    if (payload[1].length > 1) {
                        console.log(
                            `${addr} 预期不超过一个块标头（已接收: ${payload[1].length})`
                        )
                        break
                    }
                    let isValidPayload = false
                    const header = BlockHeader.fromValuesArray(payload[1][0],{ common })
                    if (header.hash().toString('hex')!= CHECK_BLOCK){
                        console.log("BLOCK_HEADERS")
                        while (requests.headers.length > 0) {
                            const blockHash = requests.headers.shift()
                            if (header.hash().toString("hex") === blockHash.toString("hex")) {
                                isValidPayload = true
                                requests.bodies.push(header)
                                requests.receipts.push(header)
                                setTimeout(() => {
                                    eth.sendMessage(devp2p.ETH.MESSAGE_CODES.GET_BLOCK_BODIES, [
                                        Buffer.from([3]),
                                        [blockHash],
                                    ])
                                }, ms('0.1s'))
                                setTimeout(() => {
                                    eth.sendMessage(devp2p.ETH.MESSAGE_CODES.GET_RECEIPTS, [
                                        Buffer.from([16549]),
                                        [header.hash()]
                                    ])
                                }, ms('0.2s'))
                                break
                            }
                        }
    
                        if (!isValidPayload) {
                            console.log(`${addr} 接收到错误的块标头 ${header.hash().toString('hex')}`)
                        }
                    }
                }

                break
            }

            case devp2p.ETH.MESSAGE_CODES.GET_BLOCK_BODIES:
                console.log("GET_BLOCK_BODIES")
                if (requests.headers.length === 0 && requests.msgTypes[code] >= 8) {
                    peer.disconnect(devp2p.DISCONNECT_REASONS.USELESS_PEER)
                } else {
                    eth.sendMessage(devp2p.ETH.MESSAGE_CODES.BLOCK_BODIES, [payload[0], []])
                }
                break

            case devp2p.ETH.MESSAGE_CODES.BLOCK_BODIES: {
                if (!forkVerified) break
                console.log("BLOCK_BODIES")
                if (payload[1].length !== 1) {
                    console.log(
                        `${addr} 预期不超过一个块体（已收到: ${payload[1].length})`
                    )
                    break
                }
                
                while (requests.bodies.length > 0) {
                    const header = requests.bodies.shift()
                    const txs = payload[1][0][0]
                    const uncleHeaders = payload[1][0][1]
                    const block = Block.fromValuesArray([header.raw(), txs, uncleHeaders], { common })
                    onNewBlock(block, peer)
                }

                break
            }

            case devp2p.ETH.MESSAGE_CODES.NEW_BLOCK: {
                if (!forkVerified) break
                console.log(`NEW_BLOCK   ${addr}`)
                const newBlock = Block.fromValuesArray(payload[0], { common })
                onNewBlock(newBlock, peer)
                // const isValidNewBlock = await isValidBlock(newBlock)
                // if (isValidNewBlock) onNewBlock(newBlock, peer)

                break
            }

            case devp2p.ETH.MESSAGE_CODES.GET_NODE_DATA:
                console.log(`GET_NODE_DATA   ${addr}`)
                if (requests.headers.length === 0 && requests.msgTypes[code] >= 8) {
                    peer.disconnect(devp2p.DISCONNECT_REASONS.USELESS_PEER)
                } else {
                    eth.sendMessage(devp2p.ETH.MESSAGE_CODES.NODE_DATA, [payload[0], []])
                }
                break

            case devp2p.ETH.MESSAGE_CODES.NODE_DATA:
                console.log(`NODE_DATA   ${addr}`)
                break

            case devp2p.ETH.MESSAGE_CODES.GET_RECEIPTS:
                console.log(`GET_RECEIPTS   ${addr}`)
                if (requests.headers.length === 0 && requests.msgTypes[code] >= 8) {
                    peer.disconnect(devp2p.DISCONNECT_REASONS.USELESS_PEER)
                } else {
                    eth.sendMessage(devp2p.ETH.MESSAGE_CODES.RECEIPTS, [payload[0], []])
                }
                break
            case devp2p.ETH.MESSAGE_CODES.RECEIPTS:
                console.log(`RECEIPTS   ${addr}`)
                clearTimeout(forkDrop)
                // for(var receipts of payload[1]){
                //     console.log(receipts)
                // }
                break
        }
    })
})

rlpx.on('peer:removed', (peer, reasonCode, disconnectWe) => {
    const who = disconnectWe === true ? 'we disconnect' : 'peer disconnect'
    const total = rlpx.getPeers().length
    console.log(
        chalk.yellow(
            `Remove peer: ${getPeerAddr(peer)} - ${who}, reason: ${peer.getDisconnectPrefix(
                reasonCode
            )} (${String(reasonCode)}) (total: ${total})`
        )
    )
})

rlpx.on('peer:error', (peer, err) => {
    if (err.code === 'ECONNRESET') return

    if (err instanceof Error) {
        const peerId = peer.getId()
        if (peerId !== null) dpt.banPeer(peerId, ms('5m'))

        console.error(chalk.red(`对等错误 (${getPeerAddr(peer)}): ${err.message}`))
        return
    }
    console.error(chalk.red(`对等错误 (${getPeerAddr(peer)}): ${err.stack ?? err}`))
})

// 如果要接受传入连接，请取消注释
rlpx.listen(30311, '0.0.0.0')
dpt.bind(30311, '0.0.0.0')

for (const bootnode of BOOTNODES) {
    dpt.bootstrap(bootnode).catch((err) => {
        console.error(chalk.bold.red(`DPT引导错误: ${err.stack ?? err}`))
    })
}

// 连接到本地ethereum节点（调试）
// bootstrapNodes.forEach((el)=>{
//     dpt.addPeer({ address: el.ip, udpPort: el.port, tcpPort: el.port }).then((peer) => {
//         return rlpx.connect({
//             id: peer.id,
//             address: peer.address,
//             tcpPort: peer.tcpPort,
//             udpPort: peer.tcpPort
//         })
//     }).catch((err) => console.log(`连接到本地节点时出错: ${err.stack ?? err}`))
// })



    
const txCache = new LRUCache({ max: 1000 })
function onNewTx(tx, peer) {
    return
    console.log("onNewTx",TransactionFactory.fromBlockBodyData(tx).toJSON())
}

function onNewTxs(txs, peer) {
    return
    for(var tx of txs){
        console.log("onNewTxs",TransactionFactory.fromBlockBodyData(tx).toJSON())
    }

    // const txHashHex = tx.hash().toString('hex')
    // if (txCache.has(txHashHex)) return

    // txCache.set(txHashHex, true)
    // console.log(`New tx: ${txHashHex} (from ${getPeerAddr(peer)})`)
}

const blocksCache = new LRUCache({ max: 100 })
function onNewBlock(block, peer) {
    const blockHashHex = block.hash().toString('hex')
    const blockNumber = block.header.number
    console.log(`New block ${blockNumber}: ${blockHashHex} (from ${getPeerAddr(peer)})`)
    // for (const tx of block.transactions){
    //     console.log("tx",tx.toJSON())
    // }
}


setInterval(() => {
    const peersCount = dpt.getPeers().length
    const openSlots = rlpx._getOpenSlots()
    const queueLength = rlpx._peersQueue.length
    const queueLength2 = rlpx._peersQueue.filter((o) => o.ts <= Date.now()).length
    console.log(
        chalk.yellow(
            `DPT中的节点总数: ${peersCount}, 开放式插槽: ${openSlots}, 队列: ${queueLength} / ${queueLength2}`
        )
    )
}, ms('5s'))