github.com/0xPolygon/supernets2-node@v0.0.0-20230711153321-2fe574524eaa/test/scripts/sequenceForcedBatch/main.go (about)

     1  package main
     2  
     3  import (
     4  	"os"
     5  	"time"
     6  
     7  	"github.com/0xPolygon/supernets2-node/etherman/smartcontracts/supernets2"
     8  	"github.com/0xPolygon/supernets2-node/hex"
     9  	"github.com/0xPolygon/supernets2-node/log"
    10  	"github.com/0xPolygon/supernets2-node/test/operations"
    11  	"github.com/ethereum/go-ethereum/accounts/abi/bind"
    12  	"github.com/ethereum/go-ethereum/common"
    13  	"github.com/ethereum/go-ethereum/ethclient"
    14  	"github.com/urfave/cli/v2"
    15  )
    16  
    17  const (
    18  	flagL1URLName        = "url"
    19  	flagSmcAddrName      = "smc"
    20  	flagGerName          = "ger"
    21  	flagTimestampName    = "timestamp"
    22  	flagTransactionsName = "transactions"
    23  	miningTimeout        = 180
    24  )
    25  
    26  var (
    27  	flagL1URL = cli.StringFlag{
    28  		Name:     flagL1URLName,
    29  		Aliases:  []string{"u"},
    30  		Usage:    "L1 node url",
    31  		Required: true,
    32  	}
    33  	flagSmcAddr = cli.StringFlag{
    34  		Name:     flagSmcAddrName,
    35  		Aliases:  []string{"a"},
    36  		Usage:    "Smart contract address",
    37  		Required: true,
    38  	}
    39  	flagGer = cli.StringFlag{
    40  		Name:     flagGerName,
    41  		Aliases:  []string{"g"},
    42  		Usage:    "Global exit root",
    43  		Required: true,
    44  	}
    45  	flagTimestamp = cli.StringFlag{
    46  		Name:     flagTimestampName,
    47  		Aliases:  []string{"t"},
    48  		Usage:    "MinForcedTimestamp",
    49  		Required: true,
    50  	}
    51  	flagTransactions = cli.StringFlag{
    52  		Name:     flagTransactionsName,
    53  		Aliases:  []string{"tx"},
    54  		Usage:    "Transactions",
    55  		Required: true,
    56  	}
    57  )
    58  
    59  func main() {
    60  	fbatchsender := cli.NewApp()
    61  	fbatchsender.Name = "sequenceForcedBatchsender"
    62  	fbatchsender.Usage = "send sequencer forced batch transactions to L1"
    63  	fbatchsender.DefaultCommand = "send"
    64  	flags := []cli.Flag{&flagL1URL, &flagSmcAddr, &flagGer, &flagTimestamp, &flagTransactions}
    65  	fbatchsender.Commands = []*cli.Command{
    66  		{
    67  			Before:  setLogLevel,
    68  			Name:    "send",
    69  			Aliases: []string{},
    70  			Flags:   flags,
    71  			Action:  sendForcedBatches,
    72  		},
    73  	}
    74  
    75  	err := fbatchsender.Run(os.Args)
    76  	if err != nil {
    77  		log.Fatal(err)
    78  	}
    79  }
    80  
    81  func setLogLevel(ctx *cli.Context) error {
    82  	logLevel := "debug"
    83  	log.Init(log.Config{
    84  		Level:   logLevel,
    85  		Outputs: []string{"stderr"},
    86  	})
    87  	return nil
    88  }
    89  
    90  func sendForcedBatches(cliCtx *cli.Context) error {
    91  	ctx := cliCtx.Context
    92  
    93  	url := cliCtx.String(flagL1URLName)
    94  	// Connect to ethereum node
    95  	ethClient, err := ethclient.Dial(url)
    96  	if err != nil {
    97  		log.Errorf("error connecting to %s: %+v", url, err)
    98  		return err
    99  	}
   100  	// Create smc client
   101  	poeAddr := common.HexToAddress(cliCtx.String(flagSmcAddrName))
   102  	poe, err := supernets2.NewSupernets2(poeAddr, ethClient)
   103  	if err != nil {
   104  		return err
   105  	}
   106  
   107  	auth, err := operations.GetAuth(operations.DefaultSequencerPrivateKey, operations.DefaultL1ChainID)
   108  	if err != nil {
   109  		return err
   110  	}
   111  
   112  	log.Info("Using address: ", auth.From)
   113  
   114  	num, err := poe.LastForceBatch(&bind.CallOpts{Pending: false})
   115  	if err != nil {
   116  		log.Error("error getting lastForBatch number. Error : ", err)
   117  		return err
   118  	}
   119  	log.Info("Number of forceBatches in the smc: ", num)
   120  
   121  	currentBlock, err := ethClient.BlockByNumber(ctx, nil)
   122  	if err != nil {
   123  		log.Error("error getting blockByNumber. Error: ", err)
   124  		return err
   125  	}
   126  	log.Debug("currentBlock.Time(): ", currentBlock.Time())
   127  
   128  	transactions, err := hex.DecodeHex(cliCtx.String(flagTransactionsName))
   129  	if err != nil {
   130  		log.Error("error decoding txs. Error: ", err)
   131  		return err
   132  	}
   133  	fbData := []supernets2.Supernets2ForcedBatchData{{
   134  		Transactions:       transactions,
   135  		GlobalExitRoot:     common.HexToHash(cliCtx.String(flagGerName)),
   136  		MinForcedTimestamp: cliCtx.Uint64(flagTimestampName),
   137  	}}
   138  	log.Warnf("%v, %+v", cliCtx.String(flagTransactionsName), fbData)
   139  	// Send forceBatch
   140  	tx, err := poe.SequenceForceBatches(auth, fbData)
   141  	if err != nil {
   142  		log.Error("error sending forceBatch. Error: ", err)
   143  		return err
   144  	}
   145  
   146  	log.Info("TxHash: ", tx.Hash())
   147  
   148  	time.Sleep(1 * time.Second)
   149  
   150  	return operations.WaitTxToBeMined(ctx, ethClient, tx, miningTimeout*time.Second)
   151  }