mirror of
https://github.com/scroll-tech/scroll.git
synced 2026-01-21 03:47:59 -05:00
553 lines
18 KiB
Go
553 lines
18 KiB
Go
package relayer
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"math/big"
|
|
"os"
|
|
"strconv"
|
|
"testing"
|
|
|
|
"github.com/agiledragon/gomonkey/v2"
|
|
"github.com/scroll-tech/go-ethereum/accounts/abi"
|
|
"github.com/scroll-tech/go-ethereum/common"
|
|
geth_types "github.com/scroll-tech/go-ethereum/core/types"
|
|
"github.com/smartystreets/goconvey/convey"
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"scroll-tech/common/types"
|
|
"scroll-tech/common/utils"
|
|
|
|
"scroll-tech/bridge/sender"
|
|
|
|
"scroll-tech/database"
|
|
"scroll-tech/database/migrate"
|
|
)
|
|
|
|
var (
|
|
templateL2Message = []*types.L2Message{
|
|
{
|
|
Nonce: 1,
|
|
Height: 1,
|
|
Sender: "0x596a746661dbed76a84556111c2872249b070e15",
|
|
Value: "100",
|
|
Target: "0x2c73620b223808297ea734d946813f0dd78eb8f7",
|
|
Calldata: "testdata",
|
|
Layer2Hash: "hash0",
|
|
},
|
|
}
|
|
)
|
|
|
|
func testCreateNewRelayer(t *testing.T) {
|
|
// Create db handler and reset db.
|
|
db, err := database.NewOrmFactory(cfg.DBConfig)
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
|
|
defer db.Close()
|
|
|
|
relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig)
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, relayer)
|
|
}
|
|
|
|
func testL2RelayerProcessSaveEvents(t *testing.T) {
|
|
// Create db handler and reset db.
|
|
db, err := database.NewOrmFactory(cfg.DBConfig)
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
|
|
defer db.Close()
|
|
|
|
l2Cfg := cfg.L2Config
|
|
relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig)
|
|
assert.NoError(t, err)
|
|
|
|
err = db.SaveL2Messages(context.Background(), templateL2Message)
|
|
assert.NoError(t, err)
|
|
|
|
traces := []*types.WrappedBlock{
|
|
{
|
|
Header: &geth_types.Header{
|
|
Number: big.NewInt(int64(templateL2Message[0].Height)),
|
|
},
|
|
Transactions: nil,
|
|
WithdrawTrieRoot: common.Hash{},
|
|
},
|
|
{
|
|
Header: &geth_types.Header{
|
|
Number: big.NewInt(int64(templateL2Message[0].Height + 1)),
|
|
},
|
|
Transactions: nil,
|
|
WithdrawTrieRoot: common.Hash{},
|
|
},
|
|
}
|
|
assert.NoError(t, db.InsertWrappedBlocks(traces))
|
|
|
|
parentBatch1 := &types.BlockBatch{
|
|
Index: 0,
|
|
Hash: common.Hash{}.Hex(),
|
|
StateRoot: common.Hash{}.Hex(),
|
|
}
|
|
batchData1 := types.NewBatchData(parentBatch1, []*types.WrappedBlock{wrappedBlock1}, nil)
|
|
dbTx, err := db.Beginx()
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, db.NewBatchInDBTx(dbTx, batchData1))
|
|
batchHash := batchData1.Hash().Hex()
|
|
assert.NoError(t, db.SetBatchHashForL2BlocksInDBTx(dbTx, []uint64{1}, batchHash))
|
|
assert.NoError(t, dbTx.Commit())
|
|
|
|
err = db.UpdateRollupStatus(context.Background(), batchHash, types.RollupFinalized)
|
|
assert.NoError(t, err)
|
|
|
|
relayer.ProcessSavedEvents()
|
|
|
|
msg, err := db.GetL2MessageByNonce(templateL2Message[0].Nonce)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, types.MsgSubmitted, msg.Status)
|
|
}
|
|
|
|
func testL2RelayerProcessCommittedBatches(t *testing.T) {
|
|
// Create db handler and reset db.
|
|
db, err := database.NewOrmFactory(cfg.DBConfig)
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
|
|
defer db.Close()
|
|
|
|
l2Cfg := cfg.L2Config
|
|
relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig)
|
|
assert.NoError(t, err)
|
|
|
|
parentBatch1 := &types.BlockBatch{
|
|
Index: 0,
|
|
Hash: common.Hash{}.Hex(),
|
|
StateRoot: common.Hash{}.Hex(),
|
|
}
|
|
batchData1 := types.NewBatchData(parentBatch1, []*types.WrappedBlock{wrappedBlock1}, nil)
|
|
dbTx, err := db.Beginx()
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, db.NewBatchInDBTx(dbTx, batchData1))
|
|
batchHash := batchData1.Hash().Hex()
|
|
err = dbTx.Commit()
|
|
assert.NoError(t, err)
|
|
|
|
err = db.UpdateRollupStatus(context.Background(), batchHash, types.RollupCommitted)
|
|
assert.NoError(t, err)
|
|
|
|
tProof := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}
|
|
tInstanceCommitments := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}
|
|
err = db.UpdateProofByHash(context.Background(), batchHash, tProof, tInstanceCommitments, 100)
|
|
assert.NoError(t, err)
|
|
err = db.UpdateProvingStatus(batchHash, types.ProvingTaskVerified)
|
|
assert.NoError(t, err)
|
|
|
|
relayer.ProcessCommittedBatches()
|
|
|
|
status, err := db.GetRollupStatus(batchHash)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, types.RollupFinalizing, status)
|
|
}
|
|
|
|
func testL2RelayerSkipBatches(t *testing.T) {
|
|
// Create db handler and reset db.
|
|
db, err := database.NewOrmFactory(cfg.DBConfig)
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
|
|
defer db.Close()
|
|
|
|
l2Cfg := cfg.L2Config
|
|
relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig)
|
|
assert.NoError(t, err)
|
|
|
|
createBatch := func(rollupStatus types.RollupStatus, provingStatus types.ProvingStatus, index uint64) string {
|
|
dbTx, err := db.Beginx()
|
|
assert.NoError(t, err)
|
|
batchData := genBatchData(t, index)
|
|
assert.NoError(t, db.NewBatchInDBTx(dbTx, batchData))
|
|
batchHash := batchData.Hash().Hex()
|
|
err = dbTx.Commit()
|
|
assert.NoError(t, err)
|
|
|
|
err = db.UpdateRollupStatus(context.Background(), batchHash, rollupStatus)
|
|
assert.NoError(t, err)
|
|
|
|
tProof := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}
|
|
tInstanceCommitments := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}
|
|
err = db.UpdateProofByHash(context.Background(), batchHash, tProof, tInstanceCommitments, 100)
|
|
assert.NoError(t, err)
|
|
err = db.UpdateProvingStatus(batchHash, provingStatus)
|
|
assert.NoError(t, err)
|
|
|
|
return batchHash
|
|
}
|
|
|
|
skipped := []string{
|
|
createBatch(types.RollupCommitted, types.ProvingTaskSkipped, 1),
|
|
createBatch(types.RollupCommitted, types.ProvingTaskFailed, 2),
|
|
}
|
|
|
|
notSkipped := []string{
|
|
createBatch(types.RollupPending, types.ProvingTaskSkipped, 3),
|
|
createBatch(types.RollupCommitting, types.ProvingTaskSkipped, 4),
|
|
createBatch(types.RollupFinalizing, types.ProvingTaskSkipped, 5),
|
|
createBatch(types.RollupFinalized, types.ProvingTaskSkipped, 6),
|
|
createBatch(types.RollupPending, types.ProvingTaskFailed, 7),
|
|
createBatch(types.RollupCommitting, types.ProvingTaskFailed, 8),
|
|
createBatch(types.RollupFinalizing, types.ProvingTaskFailed, 9),
|
|
createBatch(types.RollupFinalized, types.ProvingTaskFailed, 10),
|
|
createBatch(types.RollupCommitted, types.ProvingTaskVerified, 11),
|
|
}
|
|
|
|
relayer.ProcessCommittedBatches()
|
|
|
|
for _, id := range skipped {
|
|
status, err := db.GetRollupStatus(id)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, types.RollupFinalizationSkipped, status)
|
|
}
|
|
|
|
for _, id := range notSkipped {
|
|
status, err := db.GetRollupStatus(id)
|
|
assert.NoError(t, err)
|
|
assert.NotEqual(t, types.RollupFinalizationSkipped, status)
|
|
}
|
|
}
|
|
|
|
func testL2RelayerMsgConfirm(t *testing.T) {
|
|
// Set up the database and defer closing it.
|
|
db, err := database.NewOrmFactory(cfg.DBConfig)
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
|
|
defer db.Close()
|
|
|
|
// Insert test data.
|
|
assert.NoError(t, db.SaveL2Messages(context.Background(), []*types.L2Message{
|
|
{MsgHash: "msg-1", Nonce: 0}, {MsgHash: "msg-2", Nonce: 1},
|
|
}))
|
|
|
|
// Create and set up the Layer2 Relayer.
|
|
l2Cfg := cfg.L2Config
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig)
|
|
assert.NoError(t, err)
|
|
|
|
// Simulate message confirmations.
|
|
l2Relayer.processingMessage.Store("msg-1", "msg-1")
|
|
l2Relayer.messageSender.SendConfirmation(&sender.Confirmation{
|
|
ID: "msg-1",
|
|
IsSuccessful: true,
|
|
})
|
|
l2Relayer.processingMessage.Store("msg-2", "msg-2")
|
|
l2Relayer.messageSender.SendConfirmation(&sender.Confirmation{
|
|
ID: "msg-2",
|
|
IsSuccessful: false,
|
|
})
|
|
|
|
// Check the database for the updated status using TryTimes.
|
|
assert.True(t, utils.TryTimes(5, func() bool {
|
|
msg1, err1 := db.GetL2MessageByMsgHash("msg-1")
|
|
msg2, err2 := db.GetL2MessageByMsgHash("msg-2")
|
|
return err1 == nil && msg1.Status == types.MsgConfirmed &&
|
|
err2 == nil && msg2.Status == types.MsgRelayFailed
|
|
}))
|
|
}
|
|
|
|
func testL2RelayerRollupConfirm(t *testing.T) {
|
|
// Set up the database and defer closing it.
|
|
db, err := database.NewOrmFactory(cfg.DBConfig)
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
|
|
defer db.Close()
|
|
|
|
// Insert test data.
|
|
batches := make([]*types.BatchData, 6)
|
|
for i := 0; i < 6; i++ {
|
|
batches[i] = genBatchData(t, uint64(i))
|
|
}
|
|
|
|
dbTx, err := db.Beginx()
|
|
assert.NoError(t, err)
|
|
for _, batch := range batches {
|
|
assert.NoError(t, db.NewBatchInDBTx(dbTx, batch))
|
|
}
|
|
assert.NoError(t, dbTx.Commit())
|
|
|
|
// Create and set up the Layer2 Relayer.
|
|
l2Cfg := cfg.L2Config
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig)
|
|
assert.NoError(t, err)
|
|
|
|
// Simulate message confirmations.
|
|
processingKeys := []string{"committed-1", "committed-2", "finalized-1", "finalized-2"}
|
|
isSuccessful := []bool{true, false, true, false}
|
|
|
|
for i, key := range processingKeys[:2] {
|
|
batchHashes := []string{batches[i*2].Hash().Hex(), batches[i*2+1].Hash().Hex()}
|
|
l2Relayer.processingBatchesCommitment.Store(key, batchHashes)
|
|
l2Relayer.messageSender.SendConfirmation(&sender.Confirmation{
|
|
ID: key,
|
|
IsSuccessful: isSuccessful[i],
|
|
})
|
|
}
|
|
|
|
for i, key := range processingKeys[2:] {
|
|
batchHash := batches[i+4].Hash().Hex()
|
|
l2Relayer.processingFinalization.Store(key, batchHash)
|
|
l2Relayer.rollupSender.SendConfirmation(&sender.Confirmation{
|
|
ID: key,
|
|
IsSuccessful: isSuccessful[i+2],
|
|
TxHash: common.HexToHash("0x56789abcdef1234"),
|
|
})
|
|
}
|
|
|
|
// Check the database for the updated status using TryTimes.
|
|
ok := utils.TryTimes(5, func() bool {
|
|
expectedStatuses := []types.RollupStatus{
|
|
types.RollupCommitted,
|
|
types.RollupCommitted,
|
|
types.RollupCommitFailed,
|
|
types.RollupCommitFailed,
|
|
types.RollupFinalized,
|
|
types.RollupFinalizeFailed,
|
|
}
|
|
|
|
for i, batch := range batches[:6] {
|
|
batchInDB, err := db.GetBlockBatches(map[string]interface{}{"hash": batch.Hash().Hex()})
|
|
if err != nil || len(batchInDB) != 1 || batchInDB[0].RollupStatus != expectedStatuses[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
assert.True(t, ok)
|
|
}
|
|
|
|
func testL2RelayerGasOracleConfirm(t *testing.T) {
|
|
// Set up the database and defer closing it.
|
|
db, err := database.NewOrmFactory(cfg.DBConfig)
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
|
|
defer db.Close()
|
|
|
|
// Insert test data.
|
|
batches := make([]*types.BatchData, 2)
|
|
for i := 0; i < 2; i++ {
|
|
batches[i] = genBatchData(t, uint64(i))
|
|
}
|
|
|
|
dbTx, err := db.Beginx()
|
|
assert.NoError(t, err)
|
|
for _, batch := range batches {
|
|
assert.NoError(t, db.NewBatchInDBTx(dbTx, batch))
|
|
}
|
|
assert.NoError(t, dbTx.Commit())
|
|
|
|
// Create and set up the Layer2 Relayer.
|
|
l2Cfg := cfg.L2Config
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig)
|
|
assert.NoError(t, err)
|
|
|
|
// Simulate message confirmations.
|
|
isSuccessful := []bool{true, false}
|
|
for i, batch := range batches {
|
|
l2Relayer.gasOracleSender.SendConfirmation(&sender.Confirmation{
|
|
ID: batch.Hash().Hex(),
|
|
IsSuccessful: isSuccessful[i],
|
|
})
|
|
}
|
|
|
|
// Check the database for the updated status using TryTimes.
|
|
ok := utils.TryTimes(5, func() bool {
|
|
expectedStatuses := []types.GasOracleStatus{types.GasOracleImported, types.GasOracleFailed}
|
|
for i, batch := range batches {
|
|
gasOracle, err := db.GetBlockBatches(map[string]interface{}{"hash": batch.Hash().Hex()})
|
|
if err != nil || len(gasOracle) != 1 || gasOracle[0].OracleStatus != expectedStatuses[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
assert.True(t, ok)
|
|
}
|
|
|
|
func genBatchData(t *testing.T, index uint64) *types.BatchData {
|
|
templateBlockTrace, err := os.ReadFile("../../common/testdata/blockTrace_02.json")
|
|
assert.NoError(t, err)
|
|
// unmarshal blockTrace
|
|
wrappedBlock := &types.WrappedBlock{}
|
|
err = json.Unmarshal(templateBlockTrace, wrappedBlock)
|
|
assert.NoError(t, err)
|
|
wrappedBlock.Header.ParentHash = common.HexToHash("0x" + strconv.FormatUint(index+1, 16))
|
|
parentBatch := &types.BlockBatch{
|
|
Index: index,
|
|
Hash: "0x0000000000000000000000000000000000000000",
|
|
}
|
|
return types.NewBatchData(parentBatch, []*types.WrappedBlock{wrappedBlock}, nil)
|
|
}
|
|
|
|
func testLayer2RelayerProcessGasPriceOracle(t *testing.T) {
|
|
db, err := database.NewOrmFactory(cfg.DBConfig)
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
|
|
defer db.Close()
|
|
|
|
relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig)
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, relayer)
|
|
|
|
convey.Convey("Failed to GetLatestBatch", t, func() {
|
|
targetErr := errors.New("GetLatestBatch error")
|
|
patchGuard := gomonkey.ApplyMethodFunc(db, "GetLatestBatch", func() (*types.BlockBatch, error) {
|
|
return nil, targetErr
|
|
})
|
|
defer patchGuard.Reset()
|
|
relayer.ProcessGasPriceOracle()
|
|
})
|
|
|
|
patchGuard := gomonkey.ApplyMethodFunc(db, "GetLatestBatch", func() (*types.BlockBatch, error) {
|
|
batch := types.BlockBatch{
|
|
OracleStatus: types.GasOraclePending,
|
|
Hash: "0x0000000000000000000000000000000000000000",
|
|
}
|
|
return &batch, nil
|
|
})
|
|
defer patchGuard.Reset()
|
|
|
|
convey.Convey("Failed to fetch SuggestGasPrice from l2geth", t, func() {
|
|
targetErr := errors.New("SuggestGasPrice error")
|
|
patchGuard.ApplyMethodFunc(relayer.l2Client, "SuggestGasPrice", func(ctx context.Context) (*big.Int, error) {
|
|
return nil, targetErr
|
|
})
|
|
relayer.ProcessGasPriceOracle()
|
|
})
|
|
|
|
patchGuard.ApplyMethodFunc(relayer.l2Client, "SuggestGasPrice", func(ctx context.Context) (*big.Int, error) {
|
|
return big.NewInt(100), nil
|
|
})
|
|
|
|
convey.Convey("Failed to pack setL2BaseFee", t, func() {
|
|
targetErr := errors.New("setL2BaseFee error")
|
|
patchGuard.ApplyMethodFunc(relayer.l2GasOracleABI, "Pack", func(name string, args ...interface{}) ([]byte, error) {
|
|
return nil, targetErr
|
|
})
|
|
relayer.ProcessGasPriceOracle()
|
|
})
|
|
|
|
patchGuard.ApplyMethodFunc(relayer.l2GasOracleABI, "Pack", func(name string, args ...interface{}) ([]byte, error) {
|
|
return nil, nil
|
|
})
|
|
|
|
convey.Convey("Failed to send setL2BaseFee tx to layer2", t, func() {
|
|
targetErr := errors.New("failed to send setL2BaseFee tx to layer2 error")
|
|
patchGuard.ApplyMethodFunc(relayer.gasOracleSender, "SendTransaction", func(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (hash common.Hash, err error) {
|
|
return common.Hash{}, targetErr
|
|
})
|
|
relayer.ProcessGasPriceOracle()
|
|
})
|
|
|
|
patchGuard.ApplyMethodFunc(relayer.gasOracleSender, "SendTransaction", func(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (hash common.Hash, err error) {
|
|
return common.HexToHash("0x56789abcdef1234"), nil
|
|
})
|
|
|
|
convey.Convey("UpdateGasOracleStatusAndOracleTxHash failed", t, func() {
|
|
targetErr := errors.New("UpdateL2GasOracleStatusAndOracleTxHash error")
|
|
patchGuard.ApplyMethodFunc(db, "UpdateL2GasOracleStatusAndOracleTxHash", func(ctx context.Context, hash string, status types.GasOracleStatus, txHash string) error {
|
|
return targetErr
|
|
})
|
|
relayer.ProcessGasPriceOracle()
|
|
})
|
|
|
|
patchGuard.ApplyMethodFunc(db, "UpdateL2GasOracleStatusAndOracleTxHash", func(ctx context.Context, hash string, status types.GasOracleStatus, txHash string) error {
|
|
return nil
|
|
})
|
|
relayer.ProcessGasPriceOracle()
|
|
}
|
|
|
|
func testLayer2RelayerSendCommitTx(t *testing.T) {
|
|
db, err := database.NewOrmFactory(cfg.DBConfig)
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
|
|
defer db.Close()
|
|
|
|
relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig)
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, relayer)
|
|
|
|
var batchDataList []*types.BatchData
|
|
convey.Convey("SendCommitTx receives empty batch", t, func() {
|
|
err = relayer.SendCommitTx(batchDataList)
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
parentBatch := &types.BlockBatch{
|
|
Index: 0,
|
|
Hash: "0x0000000000000000000000000000000000000000",
|
|
}
|
|
|
|
traces := []*types.WrappedBlock{
|
|
{
|
|
Header: &geth_types.Header{
|
|
Number: big.NewInt(1000),
|
|
ParentHash: common.Hash{},
|
|
Difficulty: big.NewInt(0),
|
|
BaseFee: big.NewInt(0),
|
|
},
|
|
Transactions: nil,
|
|
WithdrawTrieRoot: common.Hash{},
|
|
},
|
|
}
|
|
|
|
blocks := []*types.WrappedBlock{traces[0]}
|
|
tmpBatchData := types.NewBatchData(parentBatch, blocks, cfg.L2Config.BatchProposerConfig.PublicInputConfig)
|
|
batchDataList = append(batchDataList, tmpBatchData)
|
|
|
|
var s abi.ABI
|
|
convey.Convey("Failed to pack commitBatches", t, func() {
|
|
targetErr := errors.New("commitBatches error")
|
|
patchGuard := gomonkey.ApplyMethodFunc(s, "Pack", func(name string, args ...interface{}) ([]byte, error) {
|
|
return nil, targetErr
|
|
})
|
|
defer patchGuard.Reset()
|
|
|
|
err = relayer.SendCommitTx(batchDataList)
|
|
assert.EqualError(t, err, targetErr.Error())
|
|
})
|
|
|
|
patchGuard := gomonkey.ApplyMethodFunc(s, "Pack", func(name string, args ...interface{}) ([]byte, error) {
|
|
return nil, nil
|
|
})
|
|
defer patchGuard.Reset()
|
|
|
|
convey.Convey("Failed to send commitBatches tx to layer1", t, func() {
|
|
targetErr := errors.New("SendTransaction failure")
|
|
patchGuard.ApplyMethodFunc(relayer.rollupSender, "SendTransaction", func(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (hash common.Hash, err error) {
|
|
return common.Hash{}, targetErr
|
|
})
|
|
err = relayer.SendCommitTx(batchDataList)
|
|
assert.EqualError(t, err, targetErr.Error())
|
|
})
|
|
|
|
patchGuard.ApplyMethodFunc(relayer.rollupSender, "SendTransaction", func(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (hash common.Hash, err error) {
|
|
return common.HexToHash("0x56789abcdef1234"), nil
|
|
})
|
|
|
|
convey.Convey("UpdateCommitTxHashAndRollupStatus failed", t, func() {
|
|
targetErr := errors.New("UpdateCommitTxHashAndRollupStatus failure")
|
|
patchGuard.ApplyMethodFunc(db, "UpdateCommitTxHashAndRollupStatus", func(ctx context.Context, hash string, commitTxHash string, status types.RollupStatus) error {
|
|
return targetErr
|
|
})
|
|
err = relayer.SendCommitTx(batchDataList)
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
patchGuard.ApplyMethodFunc(db, "UpdateCommitTxHashAndRollupStatus", func(ctx context.Context, hash string, commitTxHash string, status types.RollupStatus) error {
|
|
return nil
|
|
})
|
|
err = relayer.SendCommitTx(batchDataList)
|
|
assert.NoError(t, err)
|
|
}
|