comments

Author: avalonche

rpc/call.go

@@ -18,8 +18,8 @@ func callEveryoneWithResult[R any](
 		mx sync.Mutex
 		wg sync.WaitGroup
 
-		res  = make([]R, 0, len(rpc.Fallback)+1)
-		errs = make([]error, 0, len(rpc.Fallback)+1)
+		res  = make([]R, 0, len(rpc.fallback)+1)
+		errs = make([]error, 0, len(rpc.fallback)+1)
 	)
 
 	wg.Add(1)
@@ -29,7 +29,7 @@ func callEveryoneWithResult[R any](
 		_ctx, cancel := context.WithTimeout(ctx, rpc.timeout)
 		defer cancel()
 
-		_res, err := call(_ctx, rpc.Main)
+		_res, err := call(_ctx, rpc.main)
 
 		mx.Lock()
 		defer mx.Unlock()
@@ -43,7 +43,7 @@ func callEveryoneWithResult[R any](
 		}
 	}()
 
-	for idx, fallback := range rpc.Fallback {
+	for idx, fallback := range rpc.fallback {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
@@ -79,17 +79,17 @@ func callMainThenFallback(
 	_ctx, cancel := context.WithTimeout(ctx, rpc.timeout)
 	defer cancel()
 
-	err := call(_ctx, rpc.Main)
+	err := call(_ctx, rpc.main)
 	if err == nil {
 		return nil
 	}
 
-	errs := make([]error, 0, len(rpc.Fallback)+1)
+	errs := make([]error, 0, len(rpc.fallback)+1)
 	errs = append(errs, fmt.Errorf("%s: %w",
 		rpc.url.main, err,
 	))
 
-	for idx, fallback := range rpc.Fallback {
+	for idx, fallback := range rpc.fallback {
 		_ctx, cancel := context.WithTimeout(ctx, rpc.timeout)
 		defer cancel()
 
@@ -114,17 +114,17 @@ func callMainThenFallbackWithResult[R any](
 	_ctx, cancel := context.WithTimeout(ctx, rpc.timeout)
 	defer cancel()
 
-	res, err := call(_ctx, rpc.Main)
+	res, err := call(_ctx, rpc.main)
 	if err == nil {
 		return res, nil
 	}
 
-	errs := make([]error, 0, len(rpc.Fallback)+1)
+	errs := make([]error, 0, len(rpc.fallback)+1)
 	errs = append(errs, fmt.Errorf("%s: %w",
 		rpc.url.main, err,
 	))
 
-	for idx, fallback := range rpc.Fallback {
+	for idx, fallback := range rpc.fallback {
 		_ctx, cancel := context.WithTimeout(ctx, rpc.timeout)
 		defer cancel()
 
@@ -147,9 +147,9 @@ func callFallbackThenMainWithResult[R any](
 	rpc *RPC,
 	call func(ctx context.Context, rpc *ethclient.Client) (R, error),
 ) (R, error) {
-	errs := make([]error, 0, len(rpc.Fallback))
+	errs := make([]error, 0, len(rpc.fallback))
 
-	for idx, fallback := range rpc.Fallback {
+	for idx, fallback := range rpc.fallback {
 		_ctx, cancel := context.WithTimeout(ctx, rpc.timeout)
 		defer cancel()
 
@@ -166,7 +166,7 @@ func callFallbackThenMainWithResult[R any](
 	_ctx, cancel := context.WithTimeout(ctx, rpc.timeout)
 	defer cancel()
 
-	res, err := call(_ctx, rpc.Main)
+	res, err := call(_ctx, rpc.main)
 	if err == nil {
 		return res, nil
 	}

rpc/rpc.go

@@ -19,9 +19,9 @@ import (
 )
 
 type RPC struct {
-	Main      *ethclient.Client
+	main      *ethclient.Client
 	networkID *big.Int
-	Fallback  []*ethclient.Client
+	fallback  []*ethclient.Client
 	url       rpcUrl
 
 	timeout time.Duration
@@ -41,8 +41,8 @@ func New(networkID uint64, url string, fallback ...string) (*RPC, error) {
 	}
 
 	rpc := &RPC{
-		Main:     cli,
-		Fallback: make([]*ethclient.Client, 0, len(fallback)),
+		main:     cli,
+		fallback: make([]*ethclient.Client, 0, len(fallback)),
 		timeout:  time.Second,
 
 		url: rpcUrl{
@@ -62,15 +62,15 @@ func New(networkID uint64, url string, fallback ...string) (*RPC, error) {
 				errFailedToDial, url, err,
 			)
 		}
-		rpc.Fallback = append(rpc.Fallback, cli)
+		rpc.fallback = append(rpc.fallback, cli)
 	}
 
 	return rpc, nil
 }
 
 func (rpc *RPC) Close() {
-	rpc.Main.Close()
-	for _, rpc := range rpc.Fallback {
+	rpc.main.Close()
+	for _, rpc := range rpc.fallback {
 		rpc.Close()
 	}
 }

server/block_record.go

@@ -15,7 +15,8 @@ type blockRecord struct {
 }
 
 type blockRecordLegacy struct {
-	Number *big.Int       `json:"number"`
-	Hash   ethcommon.Hash `json:"hash"`
-	Landed bool
+	Number           *big.Int       `json:"number"`
+	Hash             ethcommon.Hash `json:"hash"`
+	Landed           bool
+	FlashblocksCount int64 `json:"flashblocks_count"`
 }