RPC와 멤풀

legacyPool := legacypool.New(config.TxPool, eth.blockchain)

eth.blobTxPool = blobpool.New(config.BlobPool, eth.blockchain,
                              legacyPool.HasPendingAuth)

eth.txPool, err = txpool.New(config.TxPool.PriceLimit, eth.blockchain,
        []txpool.SubPool{legacyPool, eth.blobTxPool})

func suitableCallbacks(receiver reflect.Value) map[string]*callback {
    typ := receiver.Type()
    callbacks := make(map[string]*callback)
    for m := 0; m < typ.NumMethod(); m++ {
        method := typ.Method(m)
        if method.PkgPath != "" {
            continue // method not exported
        }
        cb := newCallback(receiver, method.Func)
        if cb == nil {
            continue // function invalid
        }
        name := formatName(method.Name)
        callbacks[name] = cb
    }
    return callbacks
}

func (h *handler) handleCall(cp *callProc, msg *jsonrpcMessage) *jsonrpcMessage {
    ...
    callb := h.reg.callback(msg.Method)      // 등록표에서 조회

    if callb == nil {
        return msg.errorResponse(&methodNotFoundError{method: msg.Method})
    }

    args, pErr := parsePositionalArguments(msg.Params, callb.argTypes)
    if pErr != nil {
        return msg.errorResponse(&invalidParamsError{pErr.Error()})
    }
    ...
    return h.runMethod(rctx, msg, callb, args)   // callback.call 로 이어진다

func (api *TransactionAPI) SendRawTransaction(
        ctx context.Context, input hexutil.Bytes) (common.Hash, error) {

    tx := new(types.Transaction)
    if err := tx.UnmarshalBinary(input); err != nil {
        return common.Hash{}, err
    }

    // blob 사이드카 버전 변환 (blob tx만 해당)
    ...

    return SubmitTransaction(ctx, api.b, tx)
}

func SubmitTransaction(ctx context.Context, b Backend,
                       tx *types.Transaction) (common.Hash, error) {

    if err := checkTxFee(tx.GasPrice(), tx.Gas(), b.RPCTxFeeCap()); err != nil {
        return common.Hash{}, err
    }
    if !b.UnprotectedAllowed() && !tx.Protected() {
        return common.Hash{}, errors.New(
            "only replay-protected (EIP-155) transactions allowed over RPC")
    }
    if err := b.SendTx(ctx, tx); err != nil {
        return common.Hash{}, err
    }
    // sender 복원해서 Submitted transaction 로그
    return tx.Hash(), nil
}

func (b *EthAPIBackend) SendTx(ctx context.Context,
                              signedTx *types.Transaction) error {

    err := b.eth.txPool.Add([]*types.Transaction{signedTx}, false)[0]

    if b.eth.localTxTracker == nil {
        return err
    }
    if err != nil && !locals.IsTemporaryReject(err) {
        return err                          // 영구적 거절
    }
    b.eth.localTxTracker.Track(signedTx)    // 일시적이면 추적
    return nil
}

func (p *TxPool) Add(txs []*types.Transaction, sync bool) []error {
    txsets := make([][]*types.Transaction, len(p.subpools))
    splits := make([]int, len(txs))

    for i, tx := range txs {
        splits[i] = -1
        for j, subpool := range p.subpools {
            if subpool.Filter(tx) {          // 이 타입은 내 담당인가
                txsets[j] = append(txsets[j], tx)
                splits[i] = j
                break
            }
        }
    }
    for i := 0; i < len(p.subpools); i++ {
        errsets[i] = p.subpools[i].Add(txsets[i], sync)
    }

TxPool  (라우터)
트랜잭션을 하나도 갖고 있지 않다. 나누기만 한다

├─ LegacyPool
│   ├─ pending   실행 가능한 tx (계정별)
│   ├─ queue     아직 실행 불가능한 tx
│   ├─ all       해시로 찾는 색인
│   └─ priced    가격순 힙

└─ BlobPool   디스크 저장소. 타입 0x03 전용. 오늘은 열지 않는다

RPC 경로       eth_sendTransaction · eth_sendRawTransaction · GraphQL
                → SubmitTransaction → SendTx
                eth_resend → SendTx

p2p 경로       피어 전파 → txFetcher → eth/handler.go:202 addTxs

재제출 경로    core/txpool/locals/tx_tracker.go:227

                     모두 → TxPool.Add  core/txpool/txpool.go:318

func (pool *LegacyPool) ValidateTxBasics(tx *types.Transaction) error {
    opts := &txpool.ValidationOptions{
        Config: pool.chainconfig,
        Accept: 0 |
            1<<types.LegacyTxType |
            1<<types.AccessListTxType |
            1<<types.DynamicFeeTxType |
            1<<types.SetCodeTxType,
        MaxSize: txMaxSize,
        MinTip:  pool.gasTip.Load().ToBig(),
    }
    return txpool.ValidateTransaction(tx, pool.currentHead.Load(),
                                      pool.signer, opts)
}

if opts.Accept&(1<<tx.Type()) == 0 { ... }        // 1 타입, 비트 연산
if tx.Size() > opts.MaxSize { ... }               // 2 크기
rules := opts.Config.Rules(...)                   // 3 포크 활성 여부
if !rules.IsBerlin && tx.Type() != Legacy { ... }
if !rules.IsPrague && tx.Type() == SetCode { ... }
if tx.Value().Sign() < 0 { ... }                  // 4 정합성
if head.GasLimit < tx.Gas() { ... }
if tx.GasFeeCapIntCmp(tx.GasTipCap()) < 0 { ... }
from, err := types.Sender(signer, tx)             // 5 서명, 제일 비싸다
intrGas, _ := core.IntrinsicGas(...)              // 6 최소 가스
if tx.Gas() < intrGas { ... }
if tx.GasTipCapIntCmp(opts.MinTip) < 0 { ... }    // 7 최소 팁

next := opts.State.GetNonce(from)
if next > tx.Nonce() { return ErrNonceTooLow }

balance := opts.State.GetBalance(from).ToBig()
cost := tx.Cost()                     // value + gas x feeCap
if balance.Cmp(cost) < 0 {
    return ErrInsufficientFunds       // 1단계: 이 tx 하나
}

spent := opts.ExistingExpenditure(from)    // 계정 대기 tx 누적
if prev := opts.ExistingCost(from, tx.Nonce()); prev != nil {
    need := spent + (cost - prev)     // 교체면 증가분만
} else {
    need := spent + cost              // 신규면 누적에 더한다
}
if balance < need { return ErrInsufficientFunds }   // 2단계

for i, tx := range txs {
    if pool.all.Get(tx.Hash()) != nil {              // 중복, 락 없음
        errs[i] = txpool.ErrAlreadyKnown
        continue
    }
    if err := pool.ValidateTxBasics(tx); err != nil {  // 무상태, 락 없음
        errs[i] = err
        continue
    }
}

pool.mu.Lock()                                       // 여기서만 락
dirtyAddrs := pool.addTxsLocked(txs, errs)
pool.mu.Unlock()

done := pool.requestPromoteExecutables(dirtyAddrs)   // 비동기 요청

type LegacyPool struct {
    pending map[common.Address]*list  // 지금 실행 가능한 tx
    queue   *queue                    // 아직 실행 불가능한 tx
    all     *lookup                   // 해시로 찾기
    priced  *pricedList               // 가격순 힙
}

type queue struct {
    queued map[common.Address]*list      // 계정별 대기 목록
    beats  map[common.Address]time.Time  // 계정별 마지막 활동 시간
}

type list struct {
    strict    bool          // nonce가 연속이어야 하는가
    txs       *SortedMap    // nonce로 정렬된 해시맵
    totalcost *uint256.Int  // 이 목록 전체 비용
}

if pool.all.Get(hash) != nil {
    return false, txpool.ErrAlreadyKnown   // 중복 재확인
}
if err := pool.validateTx(tx); err != nil {  // 상태 기반 검증
    return false, err
}
from, _ := types.Sender(pool.signer, tx)     // 캐시에서 읽는다

if !hasPending && !hasQueued {
    if err := pool.reserver.Hold(from); err != nil {
        return false, err
    }
    defer func() {
        if err != nil { pool.reserver.Release(from) }
    }()
}

if uint64(pool.all.Slots()+numSlots(tx)) >
        pool.config.GlobalSlots+pool.config.GlobalQueue {

    if pool.priced.Underpriced(tx) {
        return false, txpool.ErrUnderpriced   // 최저가보다 싸면 탈락
    }
    ...
    drop, success := pool.priced.Discard(...)  // 싼 것들을 축출
    if !success {
        return false, ErrTxPoolOverflow
    }
}

// 이미 pending에 같은 nonce가 있으면 교체
if list := pool.pending[from]; list != nil && list.Contains(tx.Nonce()) {
    inserted, old := list.Add(tx, pool.config.PriceBump)
    if !inserted {
        return false, txpool.ErrReplaceUnderpriced
    }
    ...
    pool.queue.bump(from)
    return old != nil, nil    // 여기서 끝. queue를 거치지 않는다
}

// 교체가 아니면 queue로
replaced, err = pool.enqueueTx(hash, tx, true)

old := l.txs.Get(tx.Nonce())
if old != nil {
    if old.GasFeeCapCmp(tx) >= 0 || old.GasTipCapCmp(tx) >= 0 {
        return false, nil        // 하나라도 안 올랐으면 즉시 탈락
    }
    a := big.NewInt(100 + int64(priceBump))
    aFeeCap := new(big.Int).Mul(a, old.GasFeeCap())
    aTip    := a.Mul(a, old.GasTipCap())
    thresholdFeeCap := aFeeCap.Div(aFeeCap, big.NewInt(100))
    thresholdTip    := aTip.Div(aTip, big.NewInt(100))

    // feeCap과 tip 둘 다 임계값 이상이어야 한다
    if tx.GasFeeCapIntCmp(thresholdFeeCap) < 0 ||
       tx.GasTipCapIntCmp(thresholdTip) < 0 {
        return false, nil
    }
}

legacypool.go:913    Add
                       requestPromoteExecutables(dirtyAddrs)
                             |
                             |  (별도 고루틴)
legacypool.go:1136   scheduleReorgLoop
legacypool.go:1208   runReorg
legacypool.go:1255       promoted := pool.promoteExecutables(promoteAddrs)
legacypool.go:1405   promoteExecutables
queue.go:162             queue.promoteExecutables(...)
                             nonce가 이어지면 queue 에서 pending 으로