2016-04-14 11:18:24 -05:00
|
|
|
// Copyright 2015 The go-ethereum Authors
|
|
|
|
// This file is part of the go-ethereum library.
|
|
|
|
//
|
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
2015-07-02 11:55:18 -05:00
|
|
|
package eth
|
|
|
|
|
|
|
|
import (
|
|
|
|
"math/big"
|
2020-12-14 03:27:15 -06:00
|
|
|
"sort"
|
|
|
|
"sync"
|
2015-07-02 11:55:18 -05:00
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
all: core rework for the merge transition (#23761)
* all: work for eth1/2 transtition
* consensus/beacon, eth: change beacon difficulty to 0
* eth: updates
* all: add terminalBlockDifficulty config, fix rebasing issues
* eth: implemented merge interop spec
* internal/ethapi: update to v1.0.0.alpha.2
This commit updates the code to the new spec, moving payloadId into
it's own object. It also fixes an issue with finalizing an empty blockhash.
It also properly sets the basefee
* all: sync polishes, other fixes + refactors
* core, eth: correct semantics for LeavePoW, EnterPoS
* core: fixed rebasing artifacts
* core: light: performance improvements
* core: use keyed field (f)
* core: eth: fix compilation issues + tests
* eth/catalyst: dbetter error codes
* all: move Merger to consensus/, remove reliance on it in bc
* all: renamed EnterPoS and LeavePoW to ReachTDD and FinalizePoS
* core: make mergelogs a function
* core: use InsertChain instead of InsertBlock
* les: drop merger from lightchain object
* consensus: add merger
* core: recoverAncestors in catalyst mode
* core: fix nitpick
* all: removed merger from beacon, use TTD, nitpicks
* consensus: eth: add docstring, removed unnecessary code duplication
* consensus/beacon: better comment
* all: easy to fix nitpicks by karalabe
* consensus/beacon: verify known headers to be sure
* core: comments
* core: eth: don't drop peers who advertise blocks, nitpicks
* core: never add beacon blocks to the future queue
* core: fixed nitpicks
* consensus/beacon: simplify IsTTDReached check
* consensus/beacon: correct IsTTDReached check
Co-authored-by: rjl493456442 <garyrong0905@gmail.com>
Co-authored-by: Péter Szilágyi <peterke@gmail.com>
2021-11-26 05:23:02 -06:00
|
|
|
"github.com/ethereum/go-ethereum/consensus"
|
2017-04-04 17:16:29 -05:00
|
|
|
"github.com/ethereum/go-ethereum/consensus/ethash"
|
2015-07-02 11:55:18 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core"
|
2018-09-24 07:57:49 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
2023-06-16 07:29:40 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/txpool"
|
2015-07-02 11:55:18 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
2017-01-17 05:19:50 -06:00
|
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
2015-07-02 11:55:18 -05:00
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
"github.com/ethereum/go-ethereum/eth/downloader"
|
2020-12-14 03:27:15 -06:00
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
2016-07-08 12:59:11 -05:00
|
|
|
"github.com/ethereum/go-ethereum/event"
|
2015-07-02 11:55:18 -05:00
|
|
|
"github.com/ethereum/go-ethereum/params"
|
|
|
|
)
|
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
var (
|
|
|
|
// testKey is a private key to use for funding a tester account.
|
|
|
|
testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
|
2015-07-02 11:55:18 -05:00
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
// testAddr is the Ethereum address of the tester account.
|
|
|
|
testAddr = crypto.PubkeyToAddress(testKey.PublicKey)
|
|
|
|
)
|
2015-07-02 11:55:18 -05:00
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
// testTxPool is a mock transaction pool that blindly accepts all transactions.
|
|
|
|
// Its goal is to get around setting up a valid statedb for the balance and nonce
|
|
|
|
// checks.
|
|
|
|
type testTxPool struct {
|
|
|
|
pool map[common.Hash]*types.Transaction // Hash map of collected transactions
|
2015-12-15 11:22:48 -06:00
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
txFeed event.Feed // Notification feed to allow waiting for inclusion
|
|
|
|
lock sync.RWMutex // Protects the transaction pool
|
2015-07-02 11:55:18 -05:00
|
|
|
}
|
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
// newTestTxPool creates a mock transaction pool.
|
|
|
|
func newTestTxPool() *testTxPool {
|
|
|
|
return &testTxPool{
|
|
|
|
pool: make(map[common.Hash]*types.Transaction),
|
2015-07-02 11:55:18 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
// Has returns an indicator whether txpool has a transaction
|
|
|
|
// cached with the given hash.
|
|
|
|
func (p *testTxPool) Has(hash common.Hash) bool {
|
|
|
|
p.lock.Lock()
|
|
|
|
defer p.lock.Unlock()
|
2015-07-02 11:55:18 -05:00
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
return p.pool[hash] != nil
|
2015-07-02 11:55:18 -05:00
|
|
|
}
|
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
// Get retrieves the transaction from local txpool with given
|
|
|
|
// tx hash.
|
core/types: support for optional blob sidecar in BlobTx (#27841)
This PR removes the newly added txpool.Transaction wrapper type, and instead adds a way
of keeping the blob sidecar within types.Transaction. It's better this way because most
code in go-ethereum does not care about blob transactions, and probably never will. This
will start mattering especially on the client side of RPC, where all APIs are based on
types.Transaction. Users need to be able to use the same signing flows they already
have.
However, since blobs are only allowed in some places but not others, we will now need to
add checks to avoid creating invalid blocks. I'm still trying to figure out the best place
to do some of these. The way I have it currently is as follows:
- In block validation (import), txs are verified not to have a blob sidecar.
- In miner, we strip off the sidecar when committing the transaction into the block.
- In TxPool validation, txs must have a sidecar to be added into the blobpool.
- Note there is a special case here: when transactions are re-added because of a chain
reorg, we cannot use the transactions gathered from the old chain blocks as-is,
because they will be missing their blobs. This was previously handled by storing the
blobs into the 'blobpool limbo'. The code has now changed to store the full
transaction in the limbo instead, but it might be confusing for code readers why we're
not simply adding the types.Transaction we already have.
Code changes summary:
- txpool.Transaction removed and all uses replaced by types.Transaction again
- blobpool now stores types.Transaction instead of defining its own blobTx format for storage
- the blobpool limbo now stores types.Transaction instead of storing only the blobs
- checks to validate the presence/absence of the blob sidecar added in certain critical places
2023-08-14 03:13:34 -05:00
|
|
|
func (p *testTxPool) Get(hash common.Hash) *types.Transaction {
|
2020-12-14 03:27:15 -06:00
|
|
|
p.lock.Lock()
|
|
|
|
defer p.lock.Unlock()
|
core/types: support for optional blob sidecar in BlobTx (#27841)
This PR removes the newly added txpool.Transaction wrapper type, and instead adds a way
of keeping the blob sidecar within types.Transaction. It's better this way because most
code in go-ethereum does not care about blob transactions, and probably never will. This
will start mattering especially on the client side of RPC, where all APIs are based on
types.Transaction. Users need to be able to use the same signing flows they already
have.
However, since blobs are only allowed in some places but not others, we will now need to
add checks to avoid creating invalid blocks. I'm still trying to figure out the best place
to do some of these. The way I have it currently is as follows:
- In block validation (import), txs are verified not to have a blob sidecar.
- In miner, we strip off the sidecar when committing the transaction into the block.
- In TxPool validation, txs must have a sidecar to be added into the blobpool.
- Note there is a special case here: when transactions are re-added because of a chain
reorg, we cannot use the transactions gathered from the old chain blocks as-is,
because they will be missing their blobs. This was previously handled by storing the
blobs into the 'blobpool limbo'. The code has now changed to store the full
transaction in the limbo instead, but it might be confusing for code readers why we're
not simply adding the types.Transaction we already have.
Code changes summary:
- txpool.Transaction removed and all uses replaced by types.Transaction again
- blobpool now stores types.Transaction instead of defining its own blobTx format for storage
- the blobpool limbo now stores types.Transaction instead of storing only the blobs
- checks to validate the presence/absence of the blob sidecar added in certain critical places
2023-08-14 03:13:34 -05:00
|
|
|
return p.pool[hash]
|
2015-07-02 11:55:18 -05:00
|
|
|
}
|
2016-07-08 12:59:11 -05:00
|
|
|
|
2023-06-16 07:29:40 -05:00
|
|
|
// Add appends a batch of transactions to the pool, and notifies any
|
2020-12-14 03:27:15 -06:00
|
|
|
// listeners if the addition channel is non nil
|
core/types: support for optional blob sidecar in BlobTx (#27841)
This PR removes the newly added txpool.Transaction wrapper type, and instead adds a way
of keeping the blob sidecar within types.Transaction. It's better this way because most
code in go-ethereum does not care about blob transactions, and probably never will. This
will start mattering especially on the client side of RPC, where all APIs are based on
types.Transaction. Users need to be able to use the same signing flows they already
have.
However, since blobs are only allowed in some places but not others, we will now need to
add checks to avoid creating invalid blocks. I'm still trying to figure out the best place
to do some of these. The way I have it currently is as follows:
- In block validation (import), txs are verified not to have a blob sidecar.
- In miner, we strip off the sidecar when committing the transaction into the block.
- In TxPool validation, txs must have a sidecar to be added into the blobpool.
- Note there is a special case here: when transactions are re-added because of a chain
reorg, we cannot use the transactions gathered from the old chain blocks as-is,
because they will be missing their blobs. This was previously handled by storing the
blobs into the 'blobpool limbo'. The code has now changed to store the full
transaction in the limbo instead, but it might be confusing for code readers why we're
not simply adding the types.Transaction we already have.
Code changes summary:
- txpool.Transaction removed and all uses replaced by types.Transaction again
- blobpool now stores types.Transaction instead of defining its own blobTx format for storage
- the blobpool limbo now stores types.Transaction instead of storing only the blobs
- checks to validate the presence/absence of the blob sidecar added in certain critical places
2023-08-14 03:13:34 -05:00
|
|
|
func (p *testTxPool) Add(txs []*types.Transaction, local bool, sync bool) []error {
|
2020-12-14 03:27:15 -06:00
|
|
|
p.lock.Lock()
|
|
|
|
defer p.lock.Unlock()
|
2019-04-16 05:20:38 -05:00
|
|
|
|
core/types: support for optional blob sidecar in BlobTx (#27841)
This PR removes the newly added txpool.Transaction wrapper type, and instead adds a way
of keeping the blob sidecar within types.Transaction. It's better this way because most
code in go-ethereum does not care about blob transactions, and probably never will. This
will start mattering especially on the client side of RPC, where all APIs are based on
types.Transaction. Users need to be able to use the same signing flows they already
have.
However, since blobs are only allowed in some places but not others, we will now need to
add checks to avoid creating invalid blocks. I'm still trying to figure out the best place
to do some of these. The way I have it currently is as follows:
- In block validation (import), txs are verified not to have a blob sidecar.
- In miner, we strip off the sidecar when committing the transaction into the block.
- In TxPool validation, txs must have a sidecar to be added into the blobpool.
- Note there is a special case here: when transactions are re-added because of a chain
reorg, we cannot use the transactions gathered from the old chain blocks as-is,
because they will be missing their blobs. This was previously handled by storing the
blobs into the 'blobpool limbo'. The code has now changed to store the full
transaction in the limbo instead, but it might be confusing for code readers why we're
not simply adding the types.Transaction we already have.
Code changes summary:
- txpool.Transaction removed and all uses replaced by types.Transaction again
- blobpool now stores types.Transaction instead of defining its own blobTx format for storage
- the blobpool limbo now stores types.Transaction instead of storing only the blobs
- checks to validate the presence/absence of the blob sidecar added in certain critical places
2023-08-14 03:13:34 -05:00
|
|
|
for _, tx := range txs {
|
2020-12-14 03:27:15 -06:00
|
|
|
p.pool[tx.Hash()] = tx
|
2016-07-08 12:59:11 -05:00
|
|
|
}
|
core/types: support for optional blob sidecar in BlobTx (#27841)
This PR removes the newly added txpool.Transaction wrapper type, and instead adds a way
of keeping the blob sidecar within types.Transaction. It's better this way because most
code in go-ethereum does not care about blob transactions, and probably never will. This
will start mattering especially on the client side of RPC, where all APIs are based on
types.Transaction. Users need to be able to use the same signing flows they already
have.
However, since blobs are only allowed in some places but not others, we will now need to
add checks to avoid creating invalid blocks. I'm still trying to figure out the best place
to do some of these. The way I have it currently is as follows:
- In block validation (import), txs are verified not to have a blob sidecar.
- In miner, we strip off the sidecar when committing the transaction into the block.
- In TxPool validation, txs must have a sidecar to be added into the blobpool.
- Note there is a special case here: when transactions are re-added because of a chain
reorg, we cannot use the transactions gathered from the old chain blocks as-is,
because they will be missing their blobs. This was previously handled by storing the
blobs into the 'blobpool limbo'. The code has now changed to store the full
transaction in the limbo instead, but it might be confusing for code readers why we're
not simply adding the types.Transaction we already have.
Code changes summary:
- txpool.Transaction removed and all uses replaced by types.Transaction again
- blobpool now stores types.Transaction instead of defining its own blobTx format for storage
- the blobpool limbo now stores types.Transaction instead of storing only the blobs
- checks to validate the presence/absence of the blob sidecar added in certain critical places
2023-08-14 03:13:34 -05:00
|
|
|
p.txFeed.Send(core.NewTxsEvent{Txs: txs})
|
|
|
|
return make([]error, len(txs))
|
2019-04-16 05:20:38 -05:00
|
|
|
}
|
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
// Pending returns all the transactions known to the pool
|
2023-07-27 05:45:35 -05:00
|
|
|
func (p *testTxPool) Pending(enforceTips bool) map[common.Address][]*txpool.LazyTransaction {
|
2020-12-14 03:27:15 -06:00
|
|
|
p.lock.RLock()
|
|
|
|
defer p.lock.RUnlock()
|
2019-04-16 05:20:38 -05:00
|
|
|
|
2023-06-16 07:29:40 -05:00
|
|
|
batches := make(map[common.Address][]*types.Transaction)
|
2020-12-14 03:27:15 -06:00
|
|
|
for _, tx := range p.pool {
|
|
|
|
from, _ := types.Sender(types.HomesteadSigner{}, tx)
|
|
|
|
batches[from] = append(batches[from], tx)
|
2019-04-16 05:20:38 -05:00
|
|
|
}
|
2020-12-14 03:27:15 -06:00
|
|
|
for _, batch := range batches {
|
|
|
|
sort.Sort(types.TxByNonce(batch))
|
2016-07-08 12:59:11 -05:00
|
|
|
}
|
2023-07-27 05:45:35 -05:00
|
|
|
pending := make(map[common.Address][]*txpool.LazyTransaction)
|
|
|
|
for addr, batch := range batches {
|
|
|
|
for _, tx := range batch {
|
|
|
|
pending[addr] = append(pending[addr], &txpool.LazyTransaction{
|
|
|
|
Hash: tx.Hash(),
|
core/types: support for optional blob sidecar in BlobTx (#27841)
This PR removes the newly added txpool.Transaction wrapper type, and instead adds a way
of keeping the blob sidecar within types.Transaction. It's better this way because most
code in go-ethereum does not care about blob transactions, and probably never will. This
will start mattering especially on the client side of RPC, where all APIs are based on
types.Transaction. Users need to be able to use the same signing flows they already
have.
However, since blobs are only allowed in some places but not others, we will now need to
add checks to avoid creating invalid blocks. I'm still trying to figure out the best place
to do some of these. The way I have it currently is as follows:
- In block validation (import), txs are verified not to have a blob sidecar.
- In miner, we strip off the sidecar when committing the transaction into the block.
- In TxPool validation, txs must have a sidecar to be added into the blobpool.
- Note there is a special case here: when transactions are re-added because of a chain
reorg, we cannot use the transactions gathered from the old chain blocks as-is,
because they will be missing their blobs. This was previously handled by storing the
blobs into the 'blobpool limbo'. The code has now changed to store the full
transaction in the limbo instead, but it might be confusing for code readers why we're
not simply adding the types.Transaction we already have.
Code changes summary:
- txpool.Transaction removed and all uses replaced by types.Transaction again
- blobpool now stores types.Transaction instead of defining its own blobTx format for storage
- the blobpool limbo now stores types.Transaction instead of storing only the blobs
- checks to validate the presence/absence of the blob sidecar added in certain critical places
2023-08-14 03:13:34 -05:00
|
|
|
Tx: tx,
|
2023-07-27 05:45:35 -05:00
|
|
|
Time: tx.Time(),
|
|
|
|
GasFeeCap: tx.GasFeeCap(),
|
|
|
|
GasTipCap: tx.GasTipCap(),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return pending
|
2016-07-08 12:59:11 -05:00
|
|
|
}
|
2018-09-29 15:17:06 -05:00
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
// SubscribeNewTxsEvent should return an event subscription of NewTxsEvent and
|
|
|
|
// send events to the given channel.
|
|
|
|
func (p *testTxPool) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
|
|
|
|
return p.txFeed.Subscribe(ch)
|
2018-09-29 15:17:06 -05:00
|
|
|
}
|
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
// testHandler is a live implementation of the Ethereum protocol handler, just
|
|
|
|
// preinitialized with some sane testing defaults and the transaction pool mocked
|
|
|
|
// out.
|
|
|
|
type testHandler struct {
|
|
|
|
db ethdb.Database
|
|
|
|
chain *core.BlockChain
|
|
|
|
txpool *testTxPool
|
|
|
|
handler *handler
|
|
|
|
}
|
2020-02-17 04:01:03 -06:00
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
// newTestHandler creates a new handler for testing purposes with no blocks.
|
|
|
|
func newTestHandler() *testHandler {
|
|
|
|
return newTestHandlerWithBlocks(0)
|
2018-09-29 15:17:06 -05:00
|
|
|
}
|
2020-01-13 06:23:54 -06:00
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
// newTestHandlerWithBlocks creates a new handler for testing purposes, with a
|
|
|
|
// given number of initial blocks.
|
|
|
|
func newTestHandlerWithBlocks(blocks int) *testHandler {
|
|
|
|
// Create a database pre-initialize with a genesis block
|
|
|
|
db := rawdb.NewMemoryDatabase()
|
2022-08-30 11:22:28 -05:00
|
|
|
gspec := &core.Genesis{
|
2020-12-14 03:27:15 -06:00
|
|
|
Config: params.TestChainConfig,
|
|
|
|
Alloc: core.GenesisAlloc{testAddr: {Balance: big.NewInt(1000000)}},
|
2022-08-30 11:22:28 -05:00
|
|
|
}
|
|
|
|
chain, _ := core.NewBlockChain(db, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil)
|
2020-12-14 03:27:15 -06:00
|
|
|
|
2022-09-07 13:21:59 -05:00
|
|
|
_, bs, _ := core.GenerateChainWithGenesis(gspec, ethash.NewFaker(), blocks, nil)
|
2020-12-14 03:27:15 -06:00
|
|
|
if _, err := chain.InsertChain(bs); err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
txpool := newTestTxPool()
|
|
|
|
|
|
|
|
handler, _ := newHandler(&handlerConfig{
|
|
|
|
Database: db,
|
|
|
|
Chain: chain,
|
|
|
|
TxPool: txpool,
|
all: core rework for the merge transition (#23761)
* all: work for eth1/2 transtition
* consensus/beacon, eth: change beacon difficulty to 0
* eth: updates
* all: add terminalBlockDifficulty config, fix rebasing issues
* eth: implemented merge interop spec
* internal/ethapi: update to v1.0.0.alpha.2
This commit updates the code to the new spec, moving payloadId into
it's own object. It also fixes an issue with finalizing an empty blockhash.
It also properly sets the basefee
* all: sync polishes, other fixes + refactors
* core, eth: correct semantics for LeavePoW, EnterPoS
* core: fixed rebasing artifacts
* core: light: performance improvements
* core: use keyed field (f)
* core: eth: fix compilation issues + tests
* eth/catalyst: dbetter error codes
* all: move Merger to consensus/, remove reliance on it in bc
* all: renamed EnterPoS and LeavePoW to ReachTDD and FinalizePoS
* core: make mergelogs a function
* core: use InsertChain instead of InsertBlock
* les: drop merger from lightchain object
* consensus: add merger
* core: recoverAncestors in catalyst mode
* core: fix nitpick
* all: removed merger from beacon, use TTD, nitpicks
* consensus: eth: add docstring, removed unnecessary code duplication
* consensus/beacon: better comment
* all: easy to fix nitpicks by karalabe
* consensus/beacon: verify known headers to be sure
* core: comments
* core: eth: don't drop peers who advertise blocks, nitpicks
* core: never add beacon blocks to the future queue
* core: fixed nitpicks
* consensus/beacon: simplify IsTTDReached check
* consensus/beacon: correct IsTTDReached check
Co-authored-by: rjl493456442 <garyrong0905@gmail.com>
Co-authored-by: Péter Szilágyi <peterke@gmail.com>
2021-11-26 05:23:02 -06:00
|
|
|
Merger: consensus.NewMerger(rawdb.NewMemoryDatabase()),
|
2020-12-14 03:27:15 -06:00
|
|
|
Network: 1,
|
2021-11-26 05:26:03 -06:00
|
|
|
Sync: downloader.SnapSync,
|
2020-12-14 03:27:15 -06:00
|
|
|
BloomCache: 1,
|
|
|
|
})
|
|
|
|
handler.Start(1000)
|
|
|
|
|
|
|
|
return &testHandler{
|
|
|
|
db: db,
|
|
|
|
chain: chain,
|
|
|
|
txpool: txpool,
|
|
|
|
handler: handler,
|
2020-01-13 06:23:54 -06:00
|
|
|
}
|
2020-12-14 03:27:15 -06:00
|
|
|
}
|
2020-01-13 06:23:54 -06:00
|
|
|
|
2020-12-14 03:27:15 -06:00
|
|
|
// close tears down the handler and all its internal constructs.
|
|
|
|
func (b *testHandler) close() {
|
|
|
|
b.handler.Stop()
|
|
|
|
b.chain.Stop()
|
2020-01-13 06:23:54 -06:00
|
|
|
}
|