diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e8aee7567..b03d6cf99 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -22,32 +22,24 @@ jobs: - name: Checkout code uses: actions/checkout@v4 - name: Setup Node.js - uses: actions/setup-node@v3 + uses: actions/setup-node@v4 with: node-version: "20" - name: Setup Go uses: actions/setup-go@v2 with: - go-version: 1.21 + go-version: 1.23 - name: Install Dependencies - run: > + run: | sudo add-apt-repository -y ppa:ethereum/ethereum - sudo apt-get update - sudo apt-get install -y npm ethereum - npm install + go install github.com/ethereum/go-ethereum/cmd/abigen@v1.14.11 + go install github.com/mattn/goveralls@v0.0.11 + go install github.com/ory/go-acc@v0.2.7 + go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.61.0 - go get -d github.com/ethereum/go-ethereum@v1.12.2 \ - - && go install github.com/ethereum/go-ethereum/cmd/abigen@v1.12.2 \ - - && go install github.com/mattn/goveralls@v0.0.11 \ - - && go install github.com/ory/go-acc@v0.2.7 \ - - && go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.54.2 - name: Run make setup for mainnet run: make setup - name: Run gofmt @@ -70,7 +62,7 @@ jobs: env: COVERALLS_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: goveralls -coverprofile=coverage.txt -service=github - - uses: bissolli/gh-action-persist-workspace@v1 + - uses: bissolli/gh-action-persist-workspace@v2 with: action: persist @@ -83,34 +75,25 @@ jobs: uses: actions/checkout@v4 - name: Setup Node.js - uses: actions/setup-node@v3 + uses: actions/setup-node@v4 with: node-version: "20" - name: Setup Go uses: actions/setup-go@v2 with: - go-version: 1.21 + go-version: 1.23 - name: Install Dependencies - run: > + run: | sudo add-apt-repository -y ppa:ethereum/ethereum - sudo apt-get update - sudo apt-get install -y npm ethereum - npm install - - go get -d github.com/ethereum/go-ethereum@v1.12.2 \ - - && go install github.com/ethereum/go-ethereum/cmd/abigen@v1.12.2 \ - - && go install github.com/mattn/goveralls@v0.0.11 \ - - && go install github.com/ory/go-acc@v0.2.7 \ - - && go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.54.2 + go install github.com/ethereum/go-ethereum/cmd/abigen@v1.14.11 + go install github.com/mattn/goveralls@v0.0.11 + go install github.com/ory/go-acc@v0.2.7 + go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.61.0 - name: Create AMD Artifact run: | @@ -122,7 +105,7 @@ jobs: mv razor_go.linux-amd64.tar.gz ../../ - name: Upload AMD Artifact - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: razor_go.linux-amd64.tar.gz path: razor_go.linux-amd64.tar.gz @@ -134,34 +117,25 @@ jobs: uses: actions/checkout@v4 - name: Setup Node.js - uses: actions/setup-node@v3 + uses: actions/setup-node@v4 with: node-version: "20" - name: Setup Go uses: actions/setup-go@v2 with: - go-version: 1.21 + go-version: 1.23 - name: Install Dependencies - run: > + run: | sudo add-apt-repository -y ppa:ethereum/ethereum - sudo apt-get update - sudo apt-get install -y npm ethereum - npm install - - go get -d github.com/ethereum/go-ethereum@v1.12.2 \ - - && go install github.com/ethereum/go-ethereum/cmd/abigen@v1.12.2 \ - - && go install github.com/mattn/goveralls@v0.0.11 \ - - && go install github.com/ory/go-acc@v0.2.7 \ - - && go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.54.2 + go install github.com/ethereum/go-ethereum/cmd/abigen@v1.14.11 + go install github.com/mattn/goveralls@v0.0.11 + go install github.com/ory/go-acc@v0.2.7 + go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.61.0 - name: Create ARM Artifact run: | @@ -173,7 +147,7 @@ jobs: mv razor_go.linux-arm64.tar.gz ../../ - name: Upload ARM Artifact - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: razor_go.linux-arm64.tar.gz path: razor_go.linux-arm64.tar.gz @@ -192,17 +166,17 @@ jobs: fetch-depth: 0 - name: Setup Node.js - uses: actions/setup-node@v3 + uses: actions/setup-node@v4 with: node-version: "20" - name: Download Artifacts AMD - uses: actions/download-artifact@v3 + uses: actions/download-artifact@v4 with: name: razor_go.linux-amd64.tar.gz - name: Download Artifacts ARM - uses: actions/download-artifact@v3 + uses: actions/download-artifact@v4 with: name: razor_go.linux-arm64.tar.gz diff --git a/.github/workflows/develop.yml b/.github/workflows/develop.yml index 26ff00548..048e739c2 100644 --- a/.github/workflows/develop.yml +++ b/.github/workflows/develop.yml @@ -16,15 +16,15 @@ jobs: - name: Checkout code uses: actions/checkout@v4 - name: Setup Node.js - uses: actions/setup-node@v3 + uses: actions/setup-node@v4 with: node-version: "20" - name: Setup Go uses: actions/setup-go@v2 with: - go-version: 1.21 + go-version: 1.23 - name: Cache npm modules - uses: actions/cache@v2 + uses: actions/cache@v4 with: path: ~/.npm key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }} @@ -32,7 +32,7 @@ jobs: ${{ runner.os }}-node- - name: Cache Go dependencies - uses: actions/cache@v2 + uses: actions/cache@v4 with: path: ~/go/pkg/mod key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} @@ -45,11 +45,10 @@ jobs: sudo apt-get update sudo apt-get install -y npm ethereum npm install - go get -d github.com/ethereum/go-ethereum@v1.12.2 - go install github.com/ethereum/go-ethereum/cmd/abigen@v1.12.2 + go install github.com/ethereum/go-ethereum/cmd/abigen@v1.14.11 go install github.com/mattn/goveralls@v0.0.11 go install github.com/ory/go-acc@v0.2.7 - go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.54.2 + go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.61.0 - name: Run make setup for testnet run: make setup-testnet @@ -69,7 +68,7 @@ jobs: env: COVERALLS_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: goveralls -coverprofile=coverage.txt -service=github - - uses: bissolli/gh-action-persist-workspace@v1 + - uses: bissolli/gh-action-persist-workspace@v2 with: action: persist diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 0ab58c9a7..99f3de094 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -13,15 +13,15 @@ jobs: - name: Checkout code uses: actions/checkout@v4 - name: Setup Node.js - uses: actions/setup-node@v3 + uses: actions/setup-node@v4 with: node-version: "20" - name: Setup Go uses: actions/setup-go@v2 with: - go-version: 1.21 + go-version: 1.23 - name: Cache npm modules - uses: actions/cache@v2 + uses: actions/cache@v4 with: path: ~/.npm key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }} @@ -29,7 +29,7 @@ jobs: ${{ runner.os }}-node- - name: Cache Go dependencies - uses: actions/cache@v2 + uses: actions/cache@v4 with: path: ~/go/pkg/mod key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} @@ -42,11 +42,10 @@ jobs: sudo apt-get update sudo apt-get install -y npm ethereum npm install - go get -d github.com/ethereum/go-ethereum@v1.12.2 - go install github.com/ethereum/go-ethereum/cmd/abigen@v1.12.2 + go install github.com/ethereum/go-ethereum/cmd/abigen@v1.14.11 go install github.com/mattn/goveralls@v0.0.11 go install github.com/ory/go-acc@v0.2.7 - go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.54.2 + go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.61.0 - name: Run make setup for mainnet run: make setup @@ -66,7 +65,7 @@ jobs: env: COVERALLS_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: goveralls -coverprofile=coverage.txt -service=github - - uses: bissolli/gh-action-persist-workspace@v1 + - uses: bissolli/gh-action-persist-workspace@v2 with: action: persist diff --git a/Dockerfile.mainnet b/Dockerfile.mainnet index 9af2a71b9..92833261d 100644 --- a/Dockerfile.mainnet +++ b/Dockerfile.mainnet @@ -1,5 +1,5 @@ -FROM golang:1.21.1-alpine AS go -FROM ethereum/client-go:alltools-v1.12.2 AS ethereum +FROM golang:1.23-alpine AS go +FROM ethereum/client-go:alltools-v1.14.11 AS ethereum FROM node:18.18.0-alpine AS builder diff --git a/Dockerfile.testnet b/Dockerfile.testnet index 5437658e6..2263a11b7 100644 --- a/Dockerfile.testnet +++ b/Dockerfile.testnet @@ -1,5 +1,5 @@ -FROM golang:1.21.1-alpine AS go -FROM ethereum/client-go:alltools-v1.12.2 AS ethereum +FROM golang:1.23-alpine AS go +FROM ethereum/client-go:alltools-v1.14.11 AS ethereum FROM node:18.18.0-alpine AS builder diff --git a/README.md b/README.md index 72fd4f0da..e4a92cc9c 100644 --- a/README.md +++ b/README.md @@ -64,7 +64,7 @@ docker exec -it razor-go razor ### Prerequisites to building the source -- Golang 1.21.1 or later must be installed. +- Golang 1.23 or later must be installed. - Latest stable version of node is required. - Mac users with Silicon chips should use Node 18.18.0 LTS or later versions - `geth` and `abigen` should be installed. (Skip this step if you don't want to fetch the bindings and build from scratch) @@ -118,7 +118,7 @@ $ ./razor setConfig --provider --gasmultiplier docker ``` -docker exec -it razor-go razor setConfig --provider --alternateProvider --gasmultiplier --buffer --wait --gasprice --logLevel --gasLimit --rpcTimeout --httpTimeout --logFileMaxSize --logFileMaxBackups --logFileMaxAge +docker exec -it razor-go razor setConfig --provider --gasmultiplier --buffer --wait --gasprice --logLevel --gasLimit --rpcTimeout --httpTimeout --logFileMaxSize --logFileMaxBackups --logFileMaxAge ``` Example: @@ -190,6 +190,23 @@ Password: _Before staking on Razor Network, please ensure your account has sFUEL and RAZOR. For testnet RAZOR, please contact us on Discord._ +### Import Endpoints + +You can import the endpoints to file `$HOME/.razor/endpoints.json` on your local by using the `importEndpoints` command. +This command imports multiple providers along with the user input provider, which are then sorted according to the best performance. The best provider is thus chosen by the RPC manager and will be used to make the RPC calls. + +razor cli + +``` +$ ./razor importEndpoints +``` + +docker + +``` +docker exec -it razor-go razor importEndpoints +``` + ### Stake If you have a minimum of 1000 razors in your account, you can stake those using the addStake command. diff --git a/accounts/accounts.go b/accounts/accounts.go index 4284ed6a3..9e0a47ddb 100644 --- a/accounts/accounts.go +++ b/accounts/accounts.go @@ -13,7 +13,7 @@ import ( "strings" ) -var log = logger.NewLogger() +var log = logger.GetLogger() //This function takes path and password as input and returns new account func (am *AccountManager) CreateAccount(keystorePath string, password string) accounts.Account { diff --git a/block/block.go b/block/block.go index ea896d420..719f1cd53 100644 --- a/block/block.go +++ b/block/block.go @@ -2,40 +2,132 @@ package block import ( "context" - "razor/core" "sync" "time" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethclient" "github.com/sirupsen/logrus" + "razor/rpc" ) -var latestBlock *types.Header -var mu = sync.Mutex{} +// BlockMonitor monitors the latest block and handles stale blocks. +type BlockMonitor struct { + client *ethclient.Client + rpcManager *rpc.RPCManager + latestBlock *types.Header + mu sync.Mutex + checkInterval time.Duration + staleThreshold time.Duration +} + +// NewBlockMonitor initializes a BlockMonitor with RPC integration. +func NewBlockMonitor(client *ethclient.Client, rpcManager *rpc.RPCManager, checkInterval, staleThreshold time.Duration) *BlockMonitor { + return &BlockMonitor{ + client: client, + rpcManager: rpcManager, + checkInterval: time.Second * checkInterval, + staleThreshold: time.Second * staleThreshold, + } +} -func GetLatestBlock() *types.Header { - mu.Lock() - defer mu.Unlock() - return latestBlock +// Start begins the block monitoring process. +func (bm *BlockMonitor) Start() { + go func() { + for { + bm.updateLatestBlock() + bm.checkForStaleBlock() + time.Sleep(bm.checkInterval) + } + }() +} + +// GetLatestBlock retrieves the most recent block header safely. +func (bm *BlockMonitor) GetLatestBlock() *types.Header { + bm.mu.Lock() + defer bm.mu.Unlock() + return bm.latestBlock } -func SetLatestBlock(block *types.Header) { - mu.Lock() - latestBlock = block - mu.Unlock() +// updateLatestBlock fetches the latest block and updates the state. +func (bm *BlockMonitor) updateLatestBlock() { + if bm.client == nil { + return + } + + header, err := bm.client.HeaderByNumber(context.Background(), nil) + if err != nil { + logrus.Errorf("Error fetching latest block: %v", err) + return + } + + bm.mu.Lock() + defer bm.mu.Unlock() + + // Check if the fetched block number is less than the last recorded block number. + if bm.latestBlock != nil && header.Number.Uint64() < bm.latestBlock.Number.Uint64() { + logrus.Warnf("Fetched block number %d is less than the last recorded block number %d. Switching to the next best RPC endpoint.", + header.Number.Uint64(), bm.latestBlock.Number.Uint64()) + + // Attempt to switch to the next best RPC endpoint. + if bm.rpcManager != nil { + switched, err := bm.rpcManager.SwitchToNextBestRPCClient() + if err != nil { + logrus.Errorf("Failed to switch RPC endpoint: %v", err) + } else if switched { + logrus.Info("Switched to the next best RPC endpoint.") + bm.updateClient() + } else { + logrus.Warn("Retaining the current best RPC endpoint as no valid alternate was found.") + } + } + return + } + + // Update the latest block only if it changes. + if bm.latestBlock == nil || header.Number.Uint64() != bm.latestBlock.Number.Uint64() { + bm.latestBlock = header + } } -func CalculateLatestBlock(client *ethclient.Client) { - for { - if client != nil { - latestHeader, err := client.HeaderByNumber(context.Background(), nil) +// checkForStaleBlock detects stale blocks and triggers appropriate actions. +func (bm *BlockMonitor) checkForStaleBlock() { + if bm.staleThreshold == 0 { + return + } + + bm.mu.Lock() + defer bm.mu.Unlock() + + if bm.latestBlock == nil || time.Since(time.Unix(int64(bm.latestBlock.Time), 0)) >= bm.staleThreshold { + logrus.Warnf("Stale block detected: Block %d is stale for %s", bm.latestBlock.Number.Uint64(), bm.staleThreshold) + + // Switch to the next best RPC endpoint if stale block detected. + if bm.rpcManager != nil { + switched, err := bm.rpcManager.SwitchToNextBestRPCClient() if err != nil { - logrus.Error("CalculateBlockNumber: Error in fetching block: ", err) + logrus.Errorf("Failed to switch RPC endpoint: %v", err) + } else if switched { + logrus.Info("Switched to the next best RPC endpoint.") + bm.updateClient() } else { - SetLatestBlock(latestHeader) + logrus.Warn("Retaining the current best RPC endpoint as no valid alternate was found.") } } - time.Sleep(time.Second * time.Duration(core.BlockNumberInterval)) } } + +// updateClient updates the Ethereum client to use the new best RPC endpoint. +func (bm *BlockMonitor) updateClient() { + if bm.rpcManager == nil { + return + } + + newClient, err := bm.rpcManager.GetBestRPCClient() + if err != nil { + return + } + + bm.client = newClient + logrus.Info("Client in logger updated with the new best RPC endpoint.") +} diff --git a/block/block_test.go b/block/block_test.go new file mode 100644 index 000000000..15daf8dfe --- /dev/null +++ b/block/block_test.go @@ -0,0 +1,240 @@ +package block + +import ( + "encoding/json" + "fmt" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "math/big" + "net/http" + "net/http/httptest" + "sync/atomic" + "testing" + "time" + + "razor/rpc" +) + +func makeBlockHandler(blockNumber uint64, blockTime uint64) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + var req map[string]interface{} + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + http.Error(w, "bad request", http.StatusBadRequest) + return + } + + method, ok := req["method"].(string) + if !ok { + http.Error(w, "missing method", http.StatusBadRequest) + return + } + + var result interface{} + + switch method { + case "eth_blockNumber": + result = fmt.Sprintf("0x%x", blockNumber) + + case "eth_getBlockByNumber": + // Use go-ethereum's types.Header struct to ensure all required fields are included + header := &types.Header{ + Number: big.NewInt(int64(blockNumber)), + Time: blockTime, + ParentHash: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"), + UncleHash: types.EmptyUncleHash, + Coinbase: common.HexToAddress("0x0000000000000000000000000000000000000000"), + Root: common.HexToHash("0x2222222222222222222222222222222222222222222222222222222222222222"), + TxHash: common.HexToHash("0x3333333333333333333333333333333333333333333333333333333333333333"), + ReceiptHash: common.HexToHash("0x4444444444444444444444444444444444444444444444444444444444444444"), + Bloom: types.Bloom{}, + Difficulty: big.NewInt(2), + GasLimit: 30000000, + GasUsed: 0, + Extra: []byte{}, + } + + // Serialize the header to JSON format + result = header + default: + http.Error(w, "unsupported method", http.StatusBadRequest) + return + } + + resp := map[string]interface{}{ + "jsonrpc": "2.0", + "id": req["id"], + "result": result, + } + w.Header().Set("Content-Type", "application/json") + _ = json.NewEncoder(w).Encode(resp) + } +} + +// createManagerFromServers creates an RPCManager from a list of test servers. +func createManagerFromServers(servers ...*httptest.Server) *rpc.RPCManager { + endpoints := make([]*rpc.RPCEndpoint, len(servers)) + for i, s := range servers { + endpoints[i] = &rpc.RPCEndpoint{URL: s.URL} + } + return &rpc.RPCManager{Endpoints: endpoints} +} + +// TestBlockMonitorUpdateBlock tests `updateLatestBlock` behavior with different block numbers. +func TestBlockMonitorUpdateBlock(t *testing.T) { + // Simulate two endpoints: one returning an outdated block, another returning an up-to-date block. + blockNumber := uint64(100) + outdatedBlockNumber := uint64(90) + + ts1 := httptest.NewServer(makeBlockHandler(blockNumber, uint64(time.Now().Unix()))) + t.Cleanup(func() { ts1.Close() }) + + ts2 := httptest.NewServer(makeBlockHandler(outdatedBlockNumber, uint64(time.Now().Unix()))) + t.Cleanup(func() { ts2.Close() }) + + // Create an RPC manager with both endpoints. + manager := createManagerFromServers(ts1, ts2) + + // Refresh endpoints so that the manager pings each endpoint. + if err := manager.RefreshEndpoints(); err != nil { + t.Fatalf("RefreshEndpoints failed: %v", err) + } + + // Initialize BlockMonitor. + client, _ := manager.GetBestRPCClient() + bm := NewBlockMonitor(client, manager, 1, 10) + + // Simulate fetching the latest block. + bm.updateLatestBlock() + + if bm.latestBlock == nil { + t.Fatal("Expected latest block to be set, but got nil") + } + + // Ensure that the latest block number is from the correct, up-to-date endpoint. + if bm.latestBlock.Number.Uint64() != blockNumber { + t.Errorf("Expected block number %d, got %d", blockNumber, bm.latestBlock.Number.Uint64()) + } + + // Simulate outdated block number being reported. + bm.latestBlock.Number = big.NewInt(int64(outdatedBlockNumber)) + bm.updateLatestBlock() + + // The block number should remain at the latest, and an RPC switch should have occurred. + newBestURL, _ := manager.GetBestEndpointURL() + if newBestURL != ts1.URL { + t.Errorf("Expected best endpoint to be %s after outdated block, got %s", ts1.URL, newBestURL) + } +} + +// TestBlockMonitorStaleBlock checks if the stale block detection works correctly. +func TestBlockMonitorStaleBlock(t *testing.T) { + currentTime := uint64(time.Now().Unix()) + staleTime := uint64(time.Now().Add(-15 * time.Second).Unix()) + + ts1 := httptest.NewServer(makeBlockHandler(120, currentTime)) + t.Cleanup(func() { ts1.Close() }) + + ts2 := httptest.NewServer(makeBlockHandler(110, staleTime)) + t.Cleanup(func() { ts2.Close() }) + + // Create an RPC manager with both endpoints. + manager := createManagerFromServers(ts1, ts2) + + // Refresh endpoints so that the manager pings each endpoint. + if err := manager.RefreshEndpoints(); err != nil { + t.Fatalf("RefreshEndpoints failed: %v", err) + } + + // Initialize BlockMonitor. + client, _ := manager.GetBestRPCClient() + bm := NewBlockMonitor(client, manager, 1, 10) + + // Fetch the latest block (stale one) + bm.updateLatestBlock() + bm.checkForStaleBlock() + + if bm.latestBlock.Number.Uint64() != 120 { + t.Errorf("Expected block number 120 after detecting stale block, got %d", bm.latestBlock.Number.Uint64()) + } +} + +// TestBlockMonitorSwitchOnStale tests switching to a better endpoint when a stale block is detected. +func TestBlockMonitorSwitchOnStale(t *testing.T) { + latestBlock := uint64(150) + staleBlock := uint64(140) + + var blockNumber atomic.Uint64 + blockNumber.Store(staleBlock) + + // Simulate a server that starts with a stale block but updates to a fresh block. + ts1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + makeBlockHandler(blockNumber.Load(), uint64(time.Now().Unix()))(w, r) + })) + t.Cleanup(func() { ts1.Close() }) + + ts2 := httptest.NewServer(makeBlockHandler(latestBlock, uint64(time.Now().Unix()))) + t.Cleanup(func() { ts2.Close() }) + + // Create an RPC manager. + manager := createManagerFromServers(ts1, ts2) + + // Refresh endpoints so that the manager pings each endpoint. + if err := manager.RefreshEndpoints(); err != nil { + t.Fatalf("RefreshEndpoints failed: %v", err) + } + + // Initialize BlockMonitor. + client, _ := manager.GetBestRPCClient() + bm := NewBlockMonitor(client, manager, 1, 10) + + // Start with a stale block. + blockNumber.Store(staleBlock) + bm.updateLatestBlock() + bm.checkForStaleBlock() + + // Ensure the switch occurred to the better endpoint. + bestURL, _ := manager.GetBestEndpointURL() + if bestURL != ts2.URL { + t.Errorf("Expected best endpoint to switch to %s, got %s", ts2.URL, bestURL) + } + + // Now update the first endpoint to a fresh block. + blockNumber.Store(latestBlock) + bm.updateLatestBlock() + bm.checkForStaleBlock() + + // The monitor should detect the updated block. + if bm.latestBlock.Number.Uint64() != latestBlock { + t.Errorf("Expected latest block number %d, got %d", latestBlock, bm.latestBlock.Number.Uint64()) + } +} + +// TestBlockMonitorSwitchFailure tests when no alternate endpoints are available. +func TestBlockMonitorSwitchFailure(t *testing.T) { + staleBlock := uint64(80) + + ts1 := httptest.NewServer(makeBlockHandler(staleBlock, uint64(time.Now().Add(-20*time.Second).Unix()))) + t.Cleanup(func() { ts1.Close() }) + + // Create an RPC manager with a single stale endpoint. + manager := createManagerFromServers(ts1) + + // Refresh endpoints so that the manager pings each endpoint. + if err := manager.RefreshEndpoints(); err != nil { + t.Fatalf("RefreshEndpoints failed: %v", err) + } + + // Initialize BlockMonitor. + client, _ := manager.GetBestRPCClient() + bm := NewBlockMonitor(client, manager, 1, 10) + + // Start with a stale block. + bm.updateLatestBlock() + bm.checkForStaleBlock() + + // Since no alternate endpoints are available, the best endpoint should remain unchanged. + bestURL, _ := manager.GetBestEndpointURL() + if bestURL != ts1.URL { + t.Errorf("Expected best endpoint to remain %s, got %s", ts1.URL, bestURL) + } +} diff --git a/client/alternateClient.go b/client/alternateClient.go deleted file mode 100644 index 7d2394ff0..000000000 --- a/client/alternateClient.go +++ /dev/null @@ -1,63 +0,0 @@ -package client - -import ( - "github.com/ethereum/go-ethereum/ethclient" - "razor/logger" - "reflect" - "time" -) - -var ( - log = logger.NewLogger() - alternateClientStruct AlternateClientStruct -) - -type AlternateClientStruct struct { - switchToAlternateClient bool - alternateProvider string -} - -func StartTimerForAlternateClient(switchClientAfterTime uint64) { - log.Infof("StartTimerForAlternateClient: Alternate client will be switched back to primary client in %v seconds!", switchClientAfterTime) - time.Sleep(time.Duration(switchClientAfterTime) * time.Second) - log.Info("Switching back to primary RPC..") - SetSwitchToAlternateClientStatus(false) -} - -//ReplaceClientWithAlternateClient will replace the primary client(client from primary RPC) with secondary client which would be created using alternate RPC -func ReplaceClientWithAlternateClient(arguments []reflect.Value) []reflect.Value { - clientDataType := reflect.TypeOf((*ethclient.Client)(nil)).Elem() - for i := range arguments { - argument := arguments[i] - argumentDataType := reflect.TypeOf(argument.Interface()).Elem() - if argumentDataType != nil { - if argumentDataType == clientDataType { - alternateProvider := GetAlternateProvider() - alternateClient, dialErr := ethclient.Dial(alternateProvider) - if dialErr != nil { - log.Errorf("Error in connecting using alternate RPC %v: %v", alternateProvider, dialErr) - return arguments - } - arguments[i] = reflect.ValueOf(alternateClient) - return arguments - } - } - } - return arguments -} - -func GetSwitchToAlternateClientStatus() bool { - return alternateClientStruct.switchToAlternateClient -} - -func SetSwitchToAlternateClientStatus(status bool) { - alternateClientStruct.switchToAlternateClient = status -} - -func GetAlternateProvider() string { - return alternateClientStruct.alternateProvider -} - -func SetAlternateProvider(alternateProvider string) { - alternateClientStruct.alternateProvider = alternateProvider -} diff --git a/cmd/addStake.go b/cmd/addStake.go index b8765442d..c80445ec3 100644 --- a/cmd/addStake.go +++ b/cmd/addStake.go @@ -2,11 +2,10 @@ package cmd import ( - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/spf13/pflag" @@ -33,33 +32,11 @@ func initialiseStake(cmd *cobra.Command, args []string) { //This function sets the flags appropriately and executes the StakeCoins function func (*UtilsStruct) ExecuteStake(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteStake: config: %+v", config) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - log.Debug("ExecuteStake: Address: ", address) - - logger.SetLoggerParameters(client, address) - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) - - balance, err := razorUtils.FetchBalance(client, address) - utils.CheckError("Error in fetching razor balance for account: "+address, err) + balance, err := razorUtils.FetchBalance(rpcParameters, account.Address) + utils.CheckError("Error in fetching razor balance for account: "+account.Address, err) log.Debug("Getting amount in wei...") valueInWei, err := cmdUtils.AssignAmountInWei(flagSet) utils.CheckError("Error in getting amount: ", err) @@ -68,14 +45,14 @@ func (*UtilsStruct) ExecuteStake(flagSet *pflag.FlagSet) { log.Debug("Checking for sufficient balance...") razorUtils.CheckAmountAndBalance(valueInWei, balance) - log.Debug("Checking whether sFuel balance is not 0...") - razorUtils.CheckEthBalanceIsZero(client, address) + log.Debug("Checking whether sFUEL balance is not 0...") + razorUtils.CheckEthBalanceIsZero(rpcParameters, account.Address) - minSafeRazor, err := razorUtils.GetMinSafeRazor(client) + minSafeRazor, err := razorUtils.GetMinSafeRazor(rpcParameters) utils.CheckError("Error in getting minimum safe razor amount: ", err) log.Debug("ExecuteStake: Minimum razor that you can stake for first time: ", minSafeRazor) - stakerId, err := razorUtils.GetStakerId(client, address) + stakerId, err := razorUtils.GetStakerId(rpcParameters, account.Address) utils.CheckError("Error in getting stakerId: ", err) log.Debug("ExecuteStake: Staker Id: ", stakerId) @@ -84,7 +61,7 @@ func (*UtilsStruct) ExecuteStake(flagSet *pflag.FlagSet) { } if stakerId != 0 { - staker, err := razorUtils.GetStaker(client, stakerId) + staker, err := razorUtils.GetStaker(rpcParameters, stakerId) utils.CheckError("Error in getting staker: ", err) if staker.IsSlashed { @@ -93,7 +70,6 @@ func (*UtilsStruct) ExecuteStake(flagSet *pflag.FlagSet) { } txnArgs := types.TransactionOptions{ - Client: client, Amount: valueInWei, ChainId: core.ChainId, Config: config, @@ -101,25 +77,25 @@ func (*UtilsStruct) ExecuteStake(flagSet *pflag.FlagSet) { } log.Debug("ExecuteStake: Calling Approve() for amount: ", txnArgs.Amount) - approveTxnHash, err := cmdUtils.Approve(txnArgs) + approveTxnHash, err := cmdUtils.Approve(rpcParameters, txnArgs) utils.CheckError("Approve error: ", err) if approveTxnHash != core.NilHash { - err = razorUtils.WaitForBlockCompletion(txnArgs.Client, approveTxnHash.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, approveTxnHash.Hex()) utils.CheckError("Error in WaitForBlockCompletion for approve: ", err) } log.Debug("ExecuteStake: Calling StakeCoins() for amount: ", txnArgs.Amount) - stakeTxnHash, err := cmdUtils.StakeCoins(txnArgs) + stakeTxnHash, err := cmdUtils.StakeCoins(rpcParameters, txnArgs) utils.CheckError("Stake error: ", err) - err = razorUtils.WaitForBlockCompletion(txnArgs.Client, stakeTxnHash.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, stakeTxnHash.Hex()) utils.CheckError("Error in WaitForBlockCompletion for stake: ", err) } //This function allows the user to stake razors in the razor network and returns the hash -func (*UtilsStruct) StakeCoins(txnArgs types.TransactionOptions) (common.Hash, error) { - epoch, err := razorUtils.GetEpoch(txnArgs.Client) +func (*UtilsStruct) StakeCoins(rpcParameters rpc.RPCParameters, txnArgs types.TransactionOptions) (common.Hash, error) { + epoch, err := razorUtils.GetEpoch(rpcParameters) if err != nil { return core.NilHash, err } @@ -129,9 +105,18 @@ func (*UtilsStruct) StakeCoins(txnArgs types.TransactionOptions) (common.Hash, e txnArgs.MethodName = "stake" txnArgs.Parameters = []interface{}{epoch, txnArgs.Amount} txnArgs.ABI = bindings.StakeManagerMetaData.ABI - txnOpts := razorUtils.GetTxnOpts(txnArgs) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) + if err != nil { + return core.NilHash, err + } + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debugf("Executing Stake transaction with epoch = %d, amount = %d", epoch, txnArgs.Amount) - txn, err := stakeManagerUtils.Stake(txnArgs.Client, txnOpts, epoch, txnArgs.Amount) + txn, err := stakeManagerUtils.Stake(client, txnOpts, epoch, txnArgs.Amount) if err != nil { return core.NilHash, err } diff --git a/cmd/addStake_test.go b/cmd/addStake_test.go index df21fd316..85cb9d7fd 100644 --- a/cmd/addStake_test.go +++ b/cmd/addStake_test.go @@ -25,6 +25,7 @@ func TestStakeCoins(t *testing.T) { txnArgs types.TransactionOptions epoch uint32 getEpochErr error + txnOptsErr error stakeTxn *Types.Transaction stakeErr error hash common.Hash @@ -80,18 +81,31 @@ func TestStakeCoins(t *testing.T) { want: core.NilHash, wantErr: errors.New("stake error"), }, + { + name: "Test 4: When there is an error in getting transaction options", + args: args{ + txnArgs: types.TransactionOptions{ + Amount: big.NewInt(1000), + }, + epoch: 2, + getEpochErr: nil, + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetEpoch", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epoch, tt.args.getEpochErr) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetEpoch", mock.Anything).Return(tt.args.epoch, tt.args.getEpochErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) stakeManagerMock.On("Stake", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.stakeTxn, tt.args.stakeErr) utils := &UtilsStruct{} - got, err := utils.StakeCoins(txnArgs) + got, err := utils.StakeCoins(rpcParameters, txnArgs) if got != tt.want { t.Errorf("Txn hash for stake function, got = %v, want %v", got, tt.want) } @@ -308,14 +322,16 @@ func TestExecuteStake(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("AssignPassword", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.password) @@ -323,16 +339,16 @@ func TestExecuteStake(t *testing.T) { utilsMock.On("AccountManagerForKeystore").Return(&accounts.AccountManager{}, nil) flagSetMock.On("GetStringAddress", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.address, tt.args.addressErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) - utilsMock.On("FetchBalance", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.balance, tt.args.balanceErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) + utilsMock.On("FetchBalance", mock.Anything, mock.Anything).Return(tt.args.balance, tt.args.balanceErr) cmdUtilsMock.On("AssignAmountInWei", flagSet).Return(tt.args.amount, tt.args.amountErr) utilsMock.On("CheckAmountAndBalance", mock.AnythingOfType("*big.Int"), mock.AnythingOfType("*big.Int")).Return(tt.args.amount) - utilsMock.On("CheckEthBalanceIsZero", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return() - utilsMock.On("GetMinSafeRazor", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.minSafeRazor, tt.args.minSafeRazorErr) + utilsMock.On("CheckEthBalanceIsZero", mock.Anything, mock.Anything).Return() + utilsMock.On("GetMinSafeRazor", mock.Anything).Return(tt.args.minSafeRazor, tt.args.minSafeRazorErr) utilsMock.On("GetStakerId", mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) utilsMock.On("GetStaker", mock.Anything, mock.Anything).Return(tt.args.staker, tt.args.stakerErr) - cmdUtilsMock.On("Approve", mock.Anything).Return(tt.args.approveTxn, tt.args.approveErr) - cmdUtilsMock.On("StakeCoins", mock.Anything).Return(tt.args.stakeTxn, tt.args.stakeErr) + cmdUtilsMock.On("Approve", mock.Anything, mock.Anything).Return(tt.args.approveTxn, tt.args.approveErr) + cmdUtilsMock.On("StakeCoins", mock.Anything, mock.Anything).Return(tt.args.stakeTxn, tt.args.stakeErr) utils := &UtilsStruct{} fatal = false diff --git a/cmd/approve.go b/cmd/approve.go index 76f5e991f..a583c114a 100644 --- a/cmd/approve.go +++ b/cmd/approve.go @@ -6,12 +6,12 @@ import ( "razor/core" "razor/core/types" "razor/pkg/bindings" + "razor/rpc" ) //This function approves the transaction if the user has sufficient balance otherwise it fails the transaction -func (*UtilsStruct) Approve(txnArgs types.TransactionOptions) (common.Hash, error) { - opts := razorUtils.GetOptions() - allowance, err := tokenManagerUtils.Allowance(txnArgs.Client, &opts, common.HexToAddress(txnArgs.Account.Address), common.HexToAddress(core.StakeManagerAddress)) +func (*UtilsStruct) Approve(rpcParameters rpc.RPCParameters, txnArgs types.TransactionOptions) (common.Hash, error) { + allowance, err := razorUtils.Allowance(rpcParameters, common.HexToAddress(txnArgs.Account.Address), common.HexToAddress(core.StakeManagerAddress)) if err != nil { return core.NilHash, err } @@ -25,9 +25,18 @@ func (*UtilsStruct) Approve(txnArgs types.TransactionOptions) (common.Hash, erro txnArgs.MethodName = "approve" txnArgs.ABI = bindings.RAZORMetaData.ABI txnArgs.Parameters = []interface{}{common.HexToAddress(core.StakeManagerAddress), txnArgs.Amount} - txnOpts := razorUtils.GetTxnOpts(txnArgs) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) + if err != nil { + return core.NilHash, err + } + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debug("Executing Approve transaction with amount: ", txnArgs.Amount) - txn, err := tokenManagerUtils.Approve(txnArgs.Client, txnOpts, common.HexToAddress(core.StakeManagerAddress), txnArgs.Amount) + txn, err := tokenManagerUtils.Approve(client, txnOpts, common.HexToAddress(core.StakeManagerAddress), txnArgs.Amount) if err != nil { return core.NilHash, err } diff --git a/cmd/approve_test.go b/cmd/approve_test.go index 218c9bae4..398fcf60c 100644 --- a/cmd/approve_test.go +++ b/cmd/approve_test.go @@ -19,6 +19,7 @@ func TestApprove(t *testing.T) { callOpts bind.CallOpts allowanceAmount *big.Int allowanceError error + txnOptsErr error approveTxn *Types.Transaction approveError error hash common.Hash @@ -115,20 +116,33 @@ func TestApprove(t *testing.T) { want: common.Hash{0}, wantErr: errors.New("approve error"), }, + { + name: "Test 5: When there is error in getting txnOpts", + args: args{ + txnArgs: types.TransactionOptions{ + Amount: big.NewInt(10000), + }, + callOpts: bind.CallOpts{}, + allowanceAmount: big.NewInt(0), + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() utilsMock.On("GetOptions").Return(tt.args.callOpts) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) - tokenManagerMock.On("Allowance", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.allowanceAmount, tt.args.allowanceError) + utilsMock.On("Allowance", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.allowanceAmount, tt.args.allowanceError) tokenManagerMock.On("Approve", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.approveTxn, tt.args.approveError) utils := &UtilsStruct{} - got, err := utils.Approve(tt.args.txnArgs) + got, err := utils.Approve(rpcParameters, tt.args.txnArgs) if got != tt.want { t.Errorf("Txn hash for approve function, got = %v, want = %v", got, tt.want) } diff --git a/cmd/claimBounty.go b/cmd/claimBounty.go index 0e91572bd..9d4faaf06 100644 --- a/cmd/claimBounty.go +++ b/cmd/claimBounty.go @@ -5,16 +5,14 @@ import ( "errors" "math/big" "os" - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/path" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/cobra" "github.com/spf13/pflag" ) @@ -36,31 +34,8 @@ func initialiseClaimBounty(cmd *cobra.Command, args []string) { //This function sets the flags appropriately and executes the ClaimBounty function func (*UtilsStruct) ExecuteClaimBounty(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteClaimBounty: config: %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - log.Debug("ExecuteClaimBounty: Address: ", address) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) if razorUtils.IsFlagPassed("bountyId") { bountyId, err := flagSetUtils.GetUint32BountyId(flagSet) @@ -72,23 +47,23 @@ func (*UtilsStruct) ExecuteClaimBounty(flagSet *pflag.FlagSet) { Account: account, } - txn, err := cmdUtils.ClaimBounty(config, client, redeemBountyInput) + txn, err := cmdUtils.ClaimBounty(rpcParameters, config, redeemBountyInput) utils.CheckError("ClaimBounty error: ", err) if txn != core.NilHash { - err = razorUtils.WaitForBlockCompletion(client, txn.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txn.Hex()) utils.CheckError("Error in WaitForBlockCompletion for claimBounty: ", err) } } else { log.Debug("ExecuteClaimBounty: Calling HandleClaimBounty()") - err := cmdUtils.HandleClaimBounty(client, config, account) + err := cmdUtils.HandleClaimBounty(rpcParameters, config, account) utils.CheckError("HandleClaimBounty error: ", err) } } //This function handles claimBounty by picking bountyid's from disputeData file and if there is any error it returns the error -func (*UtilsStruct) HandleClaimBounty(client *ethclient.Client, config types.Configurations, account types.Account) error { +func (*UtilsStruct) HandleClaimBounty(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account) error { disputeFilePath, err := pathUtils.GetDisputeDataFileName(account.Address) if err != nil { return err @@ -118,12 +93,12 @@ func (*UtilsStruct) HandleClaimBounty(client *ethclient.Client, config types.Con Account: account, } log.Debugf("HandleClaimBounty: Calling ClaimBounty() with arguments redeemBountyInput: %+v", redeemBountyInput) - claimBountyTxn, err := cmdUtils.ClaimBounty(config, client, redeemBountyInput) + claimBountyTxn, err := cmdUtils.ClaimBounty(rpcParameters, config, redeemBountyInput) if err != nil { return err } if claimBountyTxn != core.NilHash { - claimBountyErr := razorUtils.WaitForBlockCompletion(client, claimBountyTxn.Hex()) + claimBountyErr := razorUtils.WaitForBlockCompletion(rpcParameters, claimBountyTxn.Hex()) if claimBountyErr == nil { if len(disputeData.BountyIdQueue) > 1 { //Removing the bountyId from the queue as the bounty is being claimed @@ -144,9 +119,8 @@ func (*UtilsStruct) HandleClaimBounty(client *ethclient.Client, config types.Con } //This function allows the users who are bountyHunter to redeem their bounty in razor network -func (*UtilsStruct) ClaimBounty(config types.Configurations, client *ethclient.Client, redeemBountyInput types.RedeemBountyInput) (common.Hash, error) { +func (*UtilsStruct) ClaimBounty(rpcParameters rpc.RPCParameters, config types.Configurations, redeemBountyInput types.RedeemBountyInput) (common.Hash, error) { txnArgs := types.TransactionOptions{ - Client: client, Account: redeemBountyInput.Account, ChainId: core.ChainId, Config: config, @@ -155,15 +129,14 @@ func (*UtilsStruct) ClaimBounty(config types.Configurations, client *ethclient.C MethodName: "redeemBounty", Parameters: []interface{}{redeemBountyInput.BountyId}, } - epoch, err := razorUtils.GetEpoch(txnArgs.Client) + epoch, err := razorUtils.GetEpoch(rpcParameters) if err != nil { log.Error("Error in getting epoch: ", err) return core.NilHash, err } log.Debug("ClaimBounty: Epoch: ", epoch) - callOpts := razorUtils.GetOptions() - bountyLock, err := stakeManagerUtils.GetBountyLock(txnArgs.Client, &callOpts, redeemBountyInput.BountyId) + bountyLock, err := razorUtils.GetBountyLock(rpcParameters, redeemBountyInput.BountyId) if err != nil { log.Error("Error in getting bounty lock: ", err) return core.NilHash, err @@ -190,10 +163,17 @@ func (*UtilsStruct) ClaimBounty(config types.Configurations, client *ethclient.C return core.NilHash, nil } - txnOpts := razorUtils.GetTxnOpts(txnArgs) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) + if err != nil { + return core.NilHash, err + } + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } log.Debug("Executing RedeemBounty transaction with bountyId: ", redeemBountyInput.BountyId) - tx, err := stakeManagerUtils.RedeemBounty(txnArgs.Client, txnOpts, redeemBountyInput.BountyId) + tx, err := stakeManagerUtils.RedeemBounty(client, txnOpts, redeemBountyInput.BountyId) if err != nil { return core.NilHash, err } diff --git a/cmd/claimBounty_test.go b/cmd/claimBounty_test.go index 848540833..82a2b2014 100644 --- a/cmd/claimBounty_test.go +++ b/cmd/claimBounty_test.go @@ -11,7 +11,6 @@ import ( utilsPkgMocks "razor/utils/mocks" "testing" - "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethclient" @@ -69,6 +68,7 @@ func TestExecuteClaimBounty(t *testing.T) { args: args{ config: types.Configurations{}, password: "test", + isFlagPassed: true, addressErr: errors.New("address error"), bountyId: 2, claimBountyTxn: common.BigToHash(big.NewInt(1)), @@ -113,13 +113,14 @@ func TestExecuteClaimBounty(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) @@ -131,8 +132,8 @@ func TestExecuteClaimBounty(t *testing.T) { utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) utilsMock.On("IsFlagPassed", mock.Anything).Return(tt.args.isFlagPassed) cmdUtilsMock.On("HandleClaimBounty", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.handleClaimBountyErr) - cmdUtilsMock.On("ClaimBounty", mock.Anything, mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.claimBountyTxn, tt.args.claimBountyErr) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) + cmdUtilsMock.On("ClaimBounty", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.claimBountyTxn, tt.args.claimBountyErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) fatal = false utils := &UtilsStruct{} @@ -148,9 +149,7 @@ func TestExecuteClaimBounty(t *testing.T) { func TestClaimBounty(t *testing.T) { var config types.Configurations - var client *ethclient.Client var bountyInput types.RedeemBountyInput - var callOpts bind.CallOpts var blockTime int64 type args struct { @@ -158,6 +157,7 @@ func TestClaimBounty(t *testing.T) { epochErr error bountyLock types.BountyLock bountyLockErr error + txnOptsErr error redeemBountyTxn *Types.Transaction redeemBountyErr error hash common.Hash @@ -251,6 +251,19 @@ func TestClaimBounty(t *testing.T) { want: core.NilHash, wantErr: nil, }, + { + name: "Test 8: When there is an error in getting txnOpts", + args: args{ + epoch: 70, + bountyLock: types.BountyLock{ + Amount: big.NewInt(1000), + RedeemAfter: 70, + }, + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -264,18 +277,17 @@ func TestClaimBounty(t *testing.T) { transactionUtils = transactionUtilsMock timeUtils = timeMock - utilsMock.On("GetEpoch", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epoch, tt.args.epochErr) - utilsMock.On("GetOptions").Return(callOpts) - stakeManagerMock.On("GetBountyLock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.CallOpts"), mock.AnythingOfType("uint32")).Return(tt.args.bountyLock, tt.args.bountyLockErr) + utilsMock.On("GetEpoch", mock.Anything).Return(tt.args.epoch, tt.args.epochErr) + utilsMock.On("GetBountyLock", mock.Anything, mock.Anything).Return(tt.args.bountyLock, tt.args.bountyLockErr) timeMock.On("Sleep", mock.AnythingOfType("time.Duration")).Return() utilsMock.On("CalculateBlockTime", mock.AnythingOfType("*ethclient.Client")).Return(blockTime) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) stakeManagerMock.On("RedeemBounty", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.TransactOpts"), mock.AnythingOfType("uint32")).Return(tt.args.redeemBountyTxn, tt.args.redeemBountyErr) utilsMock.On("SecondsToReadableTime", mock.AnythingOfType("int")).Return(tt.args.time) transactionUtilsMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.ClaimBounty(config, client, bountyInput) + got, err := utils.ClaimBounty(rpcParameters, config, bountyInput) if got != tt.want { t.Errorf("Txn hash for claimBounty function, got = %v, want = %v", got, tt.want) } @@ -294,7 +306,6 @@ func TestClaimBounty(t *testing.T) { func TestHandleClaimBounty(t *testing.T) { var ( - client *ethclient.Client config types.Configurations account types.Account fileInfo fs.FileInfo @@ -381,12 +392,12 @@ func TestHandleClaimBounty(t *testing.T) { pathMock.On("GetDisputeDataFileName", mock.AnythingOfType("string")).Return(tt.args.disputeFilePath, tt.args.disputeFilePathErr) osPathMock.On("Stat", mock.Anything).Return(fileInfo, tt.args.statErr) fileUtilsMock.On("ReadFromDisputeJsonFile", mock.Anything).Return(tt.args.disputeData, tt.args.disputeDataErr) - cmdUtilsMock.On("ClaimBounty", mock.Anything, mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.claimBountyTxn, tt.args.claimBountyTxnErr) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) + cmdUtilsMock.On("ClaimBounty", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.claimBountyTxn, tt.args.claimBountyTxnErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) fileUtilsMock.On("SaveDataToDisputeJsonFile", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.saveDataErr) ut := &UtilsStruct{} - if err := ut.HandleClaimBounty(client, config, account); (err != nil) != tt.wantErr { + if err := ut.HandleClaimBounty(rpcParameters, config, account); (err != nil) != tt.wantErr { t.Errorf("AutoClaimBounty() error = %v, wantErr %v", err, tt.wantErr) } }) diff --git a/cmd/claimCommission.go b/cmd/claimCommission.go index 6de6853df..391e203a5 100644 --- a/cmd/claimCommission.go +++ b/cmd/claimCommission.go @@ -3,10 +3,8 @@ package cmd import ( "math/big" - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" "razor/utils" @@ -28,44 +26,19 @@ Example: //This function allows the staker to claim the rewards earned from delegator's pool share as commission func (*UtilsStruct) ClaimCommission(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ClaimCommission: Config: %+v", config) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - log.Debug("ClaimCommission: Address: ", address) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) - - stakerId, err := razorUtils.GetStakerId(client, address) + stakerId, err := razorUtils.GetStakerId(rpcParameters, account.Address) utils.CheckError("Error in getting stakerId: ", err) log.Debug("ClaimCommission: Staker Id: ", stakerId) - callOpts := razorUtils.GetOptions() - stakerInfo, err := stakeManagerUtils.StakerInfo(client, &callOpts, stakerId) + stakerInfo, err := razorUtils.StakerInfo(rpcParameters, stakerId) utils.CheckError("Error in getting stakerInfo: ", err) log.Debugf("ClaimCommission: Staker Info: %+v", stakerInfo) if stakerInfo.StakerReward.Cmp(big.NewInt(0)) > 0 { - txnOpts := razorUtils.GetTxnOpts(types.TransactionOptions{ - Client: client, + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{ ChainId: core.ChainId, Config: config, ContractAddress: core.StakeManagerAddress, @@ -74,16 +47,20 @@ func (*UtilsStruct) ClaimCommission(flagSet *pflag.FlagSet) { ABI: bindings.StakeManagerMetaData.ABI, Account: account, }) + utils.CheckError("Error in getting txn options: ", err) log.Info("Claiming commission...") + client, err := rpcParameters.RPCManager.GetBestRPCClient() + utils.CheckError("Error in getting best RPC client: ", err) + log.Debug("Executing ClaimStakeReward transaction...") txn, err := stakeManagerUtils.ClaimStakerReward(client, txnOpts) utils.CheckError("Error in claiming stake reward: ", err) txnHash := transactionUtils.Hash(txn) log.Info("Txn Hash: ", txnHash.Hex()) - err = razorUtils.WaitForBlockCompletion(client, txnHash.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txnHash.Hex()) utils.CheckError("Error in WaitForBlockCompletion for claimCommission: ", err) } else { log.Error("no commission to claim") diff --git a/cmd/claimCommission_test.go b/cmd/claimCommission_test.go index 50a252130..e390f7bff 100644 --- a/cmd/claimCommission_test.go +++ b/cmd/claimCommission_test.go @@ -189,26 +189,27 @@ func TestClaimCommission(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - fatal = false + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) - utilsMock.On("GetStakerId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.stakerId, tt.args.stakerIdErr) + utilsMock.On("GetStakerId", mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) utilsMock.On("GetOptions").Return(callOpts) utilsMock.On("AssignPassword", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.password) utilsMock.On("CheckPassword", mock.Anything).Return(nil) utilsMock.On("AccountManagerForKeystore").Return(&accounts.AccountManager{}, nil) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(nil) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, nil) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) - stakeManagerMock.On("StakerInfo", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.CallOpts"), mock.AnythingOfType("uint32")).Return(tt.args.stakerInfo, tt.args.stakerInfoErr) + utilsMock.On("StakerInfo", mock.Anything, mock.AnythingOfType("uint32")).Return(tt.args.stakerInfo, tt.args.stakerInfoErr) stakeManagerMock.On("ClaimStakerReward", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.txn, tt.args.err) flagSetMock.On("GetStringAddress", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.address, tt.args.addressErr) @@ -216,6 +217,8 @@ func TestClaimCommission(t *testing.T) { transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} + fatal = false + utils.ClaimCommission(flagSet) if fatal != tt.expectedFatal { t.Error("The executeClaimBounty function didn't execute as expected") diff --git a/cmd/cmd-utils.go b/cmd/cmd-utils.go index 7786ac766..7f1fb8d21 100644 --- a/cmd/cmd-utils.go +++ b/cmd/cmd-utils.go @@ -2,20 +2,26 @@ package cmd import ( + "context" "errors" + "github.com/ethereum/go-ethereum/ethclient" "math/big" + "razor/accounts" + "razor/block" + "razor/core" + "razor/core/types" + "razor/logger" + "razor/rpc" "razor/utils" "strconv" "time" "github.com/spf13/pflag" - - "github.com/ethereum/go-ethereum/ethclient" ) //This function takes client as a parameter and returns the epoch and state -func (*UtilsStruct) GetEpochAndState(client *ethclient.Client) (uint32, int64, error) { - epoch, err := razorUtils.GetEpoch(client) +func (*UtilsStruct) GetEpochAndState(rpcParameter rpc.RPCParameters) (uint32, int64, error) { + epoch, err := razorUtils.GetEpoch(rpcParameter) if err != nil { return 0, 0, err } @@ -23,16 +29,21 @@ func (*UtilsStruct) GetEpochAndState(client *ethclient.Client) (uint32, int64, e if err != nil { return 0, 0, err } - err = ValidateBufferPercentLimit(client, bufferPercent) + err = ValidateBufferPercentLimit(rpcParameter, bufferPercent) if err != nil { return 0, 0, err } - latestHeader, err := clientUtils.GetLatestBlockWithRetry(client) + latestHeader, err := clientUtils.GetLatestBlockWithRetry(rpcParameter) if err != nil { log.Error("Error in fetching block: ", err) return 0, 0, err } - state, err := razorUtils.GetBufferedState(client, latestHeader, bufferPercent) + stateBuffer, err := razorUtils.GetStateBuffer(rpcParameter) + if err != nil { + log.Error("Error in getting state buffer: ", err) + return 0, 0, err + } + state, err := razorUtils.GetBufferedState(latestHeader, stateBuffer, bufferPercent) if err != nil { return 0, 0, err } @@ -42,10 +53,10 @@ func (*UtilsStruct) GetEpochAndState(client *ethclient.Client) (uint32, int64, e } //This function waits for the appropriate states which are required -func (*UtilsStruct) WaitForAppropriateState(client *ethclient.Client, action string, states ...int) (uint32, error) { +func (*UtilsStruct) WaitForAppropriateState(rpcParameter rpc.RPCParameters, action string, states ...int) (uint32, error) { statesAllowed := GetFormattedStateNames(states) for { - epoch, state, err := cmdUtils.GetEpochAndState(client) + epoch, state, err := cmdUtils.GetEpochAndState(rpcParameter) if err != nil { log.Error("Error in fetching epoch and state: ", err) return epoch, err @@ -60,9 +71,9 @@ func (*UtilsStruct) WaitForAppropriateState(client *ethclient.Client, action str } //This function wait if the state is commit state -func (*UtilsStruct) WaitIfCommitState(client *ethclient.Client, action string) (uint32, error) { +func (*UtilsStruct) WaitIfCommitState(rpcParameter rpc.RPCParameters, action string) (uint32, error) { for { - epoch, state, err := cmdUtils.GetEpochAndState(client) + epoch, state, err := cmdUtils.GetEpochAndState(rpcParameter) if err != nil { log.Error("Error in fetching epoch and state: ", err) return epoch, err @@ -118,3 +129,72 @@ func GetFormattedStateNames(states []int) string { } return statesAllowed } + +func InitializeCommandDependencies(flagSet *pflag.FlagSet) (types.Configurations, rpc.RPCParameters, *block.BlockMonitor, types.Account, error) { + var ( + account types.Account + client *ethclient.Client + rpcParameters rpc.RPCParameters + blockMonitor *block.BlockMonitor + ) + + config, err := cmdUtils.GetConfigData() + if err != nil { + log.Error("Error in getting config: ", err) + return types.Configurations{}, rpc.RPCParameters{}, nil, types.Account{}, err + } + log.Debugf("Config: %+v", config) + + if razorUtils.IsFlagPassed("address") { + address, err := flagSetUtils.GetStringAddress(flagSet) + if err != nil { + log.Error("Error in getting address: ", err) + return types.Configurations{}, rpc.RPCParameters{}, nil, types.Account{}, err + } + log.Debugf("Address: %v", address) + + log.Debug("Getting password...") + password := razorUtils.AssignPassword(flagSet) + + accountManager, err := razorUtils.AccountManagerForKeystore() + if err != nil { + log.Error("Error in getting accounts manager for keystore: ", err) + return types.Configurations{}, rpc.RPCParameters{}, nil, types.Account{}, err + } + + account = accounts.InitAccountStruct(address, password, accountManager) + err = razorUtils.CheckPassword(account) + if err != nil { + log.Error("Error in fetching private key from given password: ", err) + return types.Configurations{}, rpc.RPCParameters{}, nil, types.Account{}, err + } + } + + rpcManager, err := rpc.InitializeRPCManager(config.Provider) + if err != nil { + log.Error("Error in initializing RPC Manager: ", err) + return types.Configurations{}, rpc.RPCParameters{}, nil, types.Account{}, err + } + + rpcParameters = rpc.RPCParameters{ + RPCManager: rpcManager, + Ctx: context.Background(), + } + + client, err = rpcManager.GetBestRPCClient() + if err != nil { + log.Error("Error in getting best RPC client: ", err) + return types.Configurations{}, rpc.RPCParameters{}, nil, types.Account{}, err + } + + // Initialize BlockMonitor with RPCManager + blockMonitor = block.NewBlockMonitor(client, rpcManager, core.BlockNumberInterval, core.StaleBlockNumberCheckInterval) + blockMonitor.Start() + log.Debug("Checking to assign log file...") + fileUtils.AssignLogFile(flagSet, config) + + // Update Logger Instance + logger.UpdateLogger(account.Address, client, blockMonitor) + + return config, rpcParameters, blockMonitor, account, nil +} diff --git a/cmd/cmd-utils_test.go b/cmd/cmd-utils_test.go index f91d14522..09b9ab8b3 100644 --- a/cmd/cmd-utils_test.go +++ b/cmd/cmd-utils_test.go @@ -3,7 +3,6 @@ package cmd import ( "errors" Types "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/pflag" "github.com/stretchr/testify/mock" "math/big" @@ -11,7 +10,6 @@ import ( ) func TestGetEpochAndState(t *testing.T) { - var client *ethclient.Client type args struct { epoch uint32 @@ -130,14 +128,14 @@ func TestGetEpochAndState(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetEpoch", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epoch, tt.args.epochErr) + utilsMock.On("GetEpoch", mock.Anything).Return(tt.args.epoch, tt.args.epochErr) cmdUtilsMock.On("GetBufferPercent").Return(tt.args.bufferPercent, tt.args.bufferPercentErr) utilsMock.On("GetStateBuffer", mock.Anything).Return(tt.args.stateBuffer, tt.args.stateBufferErr) - clientUtilsMock.On("GetLatestBlockWithRetry", mock.Anything).Return(tt.args.latestHeader, tt.args.latestHeaderErr) + clientUtilsMock.On("GetLatestBlockWithRetry", mock.Anything, mock.Anything).Return(tt.args.latestHeader, tt.args.latestHeaderErr) utilsMock.On("GetBufferedState", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.state, tt.args.stateErr) utils := &UtilsStruct{} - gotEpoch, gotState, err := utils.GetEpochAndState(client) + gotEpoch, gotState, err := utils.GetEpochAndState(rpcParameters) if gotEpoch != tt.wantEpoch { t.Errorf("GetEpochAndState() got epoch = %v, want %v", gotEpoch, tt.wantEpoch) } @@ -158,8 +156,6 @@ func TestGetEpochAndState(t *testing.T) { } func TestWaitForAppropriateState(t *testing.T) { - var client *ethclient.Client - type args struct { epoch uint32 state int64 @@ -221,10 +217,10 @@ func TestWaitForAppropriateState(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - cmdUtilsMock.On("GetEpochAndState", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.epoch, tt.args.state, tt.args.epochOrStateErr) + cmdUtilsMock.On("GetEpochAndState", mock.Anything, mock.Anything).Return(tt.args.epoch, tt.args.state, tt.args.epochOrStateErr) timeMock.On("Sleep", mock.Anything).Return() utils := &UtilsStruct{} - got, err := utils.WaitForAppropriateState(client, tt.args.action, tt.args.states) + got, err := utils.WaitForAppropriateState(rpcParameters, tt.args.action, tt.args.states) if got != tt.want { t.Errorf("WaitForAppropriateState() function, got = %v, want = %v", got, tt.want) } @@ -242,7 +238,6 @@ func TestWaitForAppropriateState(t *testing.T) { } func TestWaitIfCommitState(t *testing.T) { - var client *ethclient.Client var action string type args struct { @@ -278,12 +273,12 @@ func TestWaitIfCommitState(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - cmdUtilsMock.On("GetEpochAndState", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epoch, tt.args.state, tt.args.epochOrStateErr) + cmdUtilsMock.On("GetEpochAndState", mock.Anything, mock.Anything).Return(tt.args.epoch, tt.args.state, tt.args.epochOrStateErr) timeMock.On("Sleep", mock.Anything).Return() utils := &UtilsStruct{} - got, err := utils.WaitIfCommitState(client, action) + got, err := utils.WaitIfCommitState(rpcParameters, action) if got != tt.want { t.Errorf("WaitIfCommitState() function, got = %v, want = %v", got, tt.want) } diff --git a/cmd/collectionList.go b/cmd/collectionList.go index 2918d7797..afee6cc77 100644 --- a/cmd/collectionList.go +++ b/cmd/collectionList.go @@ -4,12 +4,11 @@ package cmd import ( "encoding/json" "os" - "razor/logger" + "razor/rpc" "razor/utils" "strconv" "strings" - "github.com/ethereum/go-ethereum/ethclient" "github.com/olekukonko/tablewriter" "github.com/spf13/cobra" "github.com/spf13/pflag" @@ -32,21 +31,17 @@ func initialiseCollectionList(cmd *cobra.Command, args []string) { //This function sets the flags appropriately and and executes the GetCollectionList function func (*UtilsStruct) ExecuteCollectionList(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteCollectionList: Config: %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - logger.SetLoggerParameters(client, "") + _, rpcParameters, _, _, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) log.Debug("Calling GetCollectionList()") - err = cmdUtils.GetCollectionList(client) + err = cmdUtils.GetCollectionList(rpcParameters) utils.CheckError("Error in getting collection list: ", err) } //This function provides the list of all collections with their name, power, ID etc. -func (*UtilsStruct) GetCollectionList(client *ethclient.Client) error { - collections, err := razorUtils.GetAllCollections(client) +func (*UtilsStruct) GetCollectionList(rpcParameters rpc.RPCParameters) error { + collections, err := razorUtils.GetAllCollections(rpcParameters) log.Debugf("GetCollectionList: Collections: %+v", collections) if err != nil { diff --git a/cmd/collectionList_test.go b/cmd/collectionList_test.go index bd9f87479..2613ca61e 100644 --- a/cmd/collectionList_test.go +++ b/cmd/collectionList_test.go @@ -11,7 +11,6 @@ import ( ) func TestGetCollectionList(t *testing.T) { - var client *ethclient.Client type fields struct { razorUtils Utils } @@ -37,7 +36,6 @@ func TestGetCollectionList(t *testing.T) { } type args struct { - client *ethclient.Client collectionList []bindings.StructsCollection collectionListErr error } @@ -51,7 +49,6 @@ func TestGetCollectionList(t *testing.T) { name: "Test 1: When collectionList executes properly", fields: testUtils, args: args{ - client: client, collectionList: collectionListArray, collectionListErr: nil, }, @@ -62,7 +59,6 @@ func TestGetCollectionList(t *testing.T) { name: "Test 2: When there is a error fetching collection list ", fields: testUtils, args: args{ - client: client, collectionListErr: errors.New("error in fetching collection list"), }, wantErr: errors.New("error in fetching collection list"), @@ -72,10 +68,10 @@ func TestGetCollectionList(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetAllCollections", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.collectionList, tt.args.collectionListErr) + utilsMock.On("GetAllCollections", mock.Anything).Return(tt.args.collectionList, tt.args.collectionListErr) utils := &UtilsStruct{} - err := utils.GetCollectionList(tt.args.client) + err := utils.GetCollectionList(rpcParameters) if err == nil || tt.wantErr == nil { if err != tt.wantErr { @@ -133,18 +129,20 @@ func TestExecuteCollectionList(t *testing.T) { expectedFatal: true, }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(false) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - cmdUtilsMock.On("GetCollectionList", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.collectionListErr) + cmdUtilsMock.On("GetCollectionList", mock.Anything).Return(tt.args.collectionListErr) utils := &UtilsStruct{} fatal = false diff --git a/cmd/commit.go b/cmd/commit.go index 0e2a68763..1e5a01d59 100644 --- a/cmd/commit.go +++ b/cmd/commit.go @@ -9,11 +9,11 @@ import ( "razor/core" "razor/core/types" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "sync" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" solsha3 "github.com/miguelmota/go-solidity-sha3" ) @@ -21,28 +21,28 @@ import ( GetSalt calculates the salt on the basis of previous epoch and the medians of the previous epoch. If the previous epoch doesn't contain any medians, then the value is fetched from the smart contract. */ -func (*UtilsStruct) GetSalt(client *ethclient.Client, epoch uint32) ([32]byte, error) { +func (*UtilsStruct) GetSalt(rpcParameters rpc.RPCParameters, epoch uint32) ([32]byte, error) { previousEpoch := epoch - 1 log.Debug("GetSalt: Previous epoch: ", previousEpoch) - numProposedBlock, err := razorUtils.GetNumberOfProposedBlocks(client, previousEpoch) + numProposedBlock, err := razorUtils.GetNumberOfProposedBlocks(rpcParameters, previousEpoch) if err != nil { return [32]byte{}, err } log.Debug("GetSalt: Number of proposed blocks: ", numProposedBlock) - blockIndexToBeConfirmed, err := razorUtils.GetBlockIndexToBeConfirmed(client) + blockIndexToBeConfirmed, err := razorUtils.GetBlockIndexToBeConfirmed(rpcParameters) if err != nil { return [32]byte{}, err } log.Debug("GetSalt: Block Index to be confirmed: ", blockIndexToBeConfirmed) if numProposedBlock == 0 || (numProposedBlock > 0 && blockIndexToBeConfirmed < 0) { - return utils.VoteManagerInterface.GetSaltFromBlockchain(client) + return razorUtils.GetSaltFromBlockchain(rpcParameters) } - blockId, err := razorUtils.GetSortedProposedBlockId(client, previousEpoch, big.NewInt(int64(blockIndexToBeConfirmed))) + blockId, err := razorUtils.GetSortedProposedBlockId(rpcParameters, previousEpoch, big.NewInt(int64(blockIndexToBeConfirmed))) if err != nil { return [32]byte{}, errors.New("Error in getting blockId: " + err.Error()) } log.Debug("GetSalt: Block Id: ", blockId) - previousBlock, err := razorUtils.GetProposedBlock(client, previousEpoch, blockId) + previousBlock, err := razorUtils.GetProposedBlock(rpcParameters, previousEpoch, blockId) if err != nil { return [32]byte{}, errors.New("Error in getting previous block: " + err.Error()) } @@ -55,14 +55,14 @@ func (*UtilsStruct) GetSalt(client *ethclient.Client, epoch uint32) ([32]byte, e HandleCommitState fetches the collections assigned to the staker and creates the leaves required for the merkle tree generation. Values for only the collections assigned to the staker is fetched for others, 0 is added to the leaves of tree. */ -func (*UtilsStruct) HandleCommitState(client *ethclient.Client, epoch uint32, seed []byte, commitParams *types.CommitParams, rogueData types.Rogue) (types.CommitData, error) { - numActiveCollections, err := razorUtils.GetNumActiveCollections(client) +func (*UtilsStruct) HandleCommitState(rpcParameters rpc.RPCParameters, epoch uint32, seed []byte, commitParams *types.CommitParams, rogueData types.Rogue) (types.CommitData, error) { + numActiveCollections, err := razorUtils.GetNumActiveCollections(rpcParameters) if err != nil { return types.CommitData{}, err } log.Debug("HandleCommitState: Number of active collections: ", numActiveCollections) log.Debugf("HandleCommitState: Calling GetAssignedCollections() with arguments number of active collections = %d", numActiveCollections) - assignedCollections, seqAllottedCollections, err := razorUtils.GetAssignedCollections(client, numActiveCollections, seed) + assignedCollections, seqAllottedCollections, err := razorUtils.GetAssignedCollections(rpcParameters, numActiveCollections, seed) if err != nil { return types.CommitData{}, err } @@ -88,13 +88,13 @@ func (*UtilsStruct) HandleCommitState(client *ethclient.Client, epoch uint32, se log.Debugf("HandleCommitState: Is the collection at iterating index %v assigned: %v ", i, assignedCollections[i]) if assignedCollections[i] { - collectionId, err := razorUtils.GetCollectionIdFromIndex(client, uint16(i)) + collectionId, err := razorUtils.GetCollectionIdFromIndex(rpcParameters, uint16(i)) if err != nil { log.Error("Error in getting collection ID: ", err) errChan <- err return } - collectionData, err := razorUtils.GetAggregatedDataOfCollection(client, collectionId, epoch, commitParams) + collectionData, err := razorUtils.GetAggregatedDataOfCollection(rpcParameters, collectionId, epoch, commitParams) if err != nil { log.Error("Error in getting aggregated data of collection: ", err) errChan <- err @@ -145,20 +145,13 @@ func (*UtilsStruct) HandleCommitState(client *ethclient.Client, epoch uint32, se /* Commit finally commits the data to the smart contract. It calculates the commitment to send using the merkle tree root and the seed. */ -func (*UtilsStruct) Commit(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, latestHeader *Types.Header, seed []byte, values []*big.Int) (common.Hash, error) { - if state, err := razorUtils.GetBufferedState(client, latestHeader, config.BufferPercent); err != nil || state != 0 { +func (*UtilsStruct) Commit(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, latestHeader *Types.Header, stateBuffer uint64, commitmentToSend [32]byte) (common.Hash, error) { + if state, err := razorUtils.GetBufferedState(latestHeader, stateBuffer, config.BufferPercent); err != nil || state != 0 { log.Error("Not commit state") return core.NilHash, err } - commitmentToSend, err := CalculateCommitment(seed, values) - if err != nil { - log.Error("Error in getting commitment: ", err) - return core.NilHash, err - } - - txnOpts := razorUtils.GetTxnOpts(types.TransactionOptions{ - Client: client, + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{ ChainId: core.ChainId, Config: config, ContractAddress: core.VoteManagerAddress, @@ -167,8 +160,17 @@ func (*UtilsStruct) Commit(client *ethclient.Client, config types.Configurations Parameters: []interface{}{epoch, commitmentToSend}, Account: account, }) + if err != nil { + return core.NilHash, err + } log.Info("Commitment sent...") + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + log.Error(err) + return core.NilHash, err + } + log.Debugf("Executing Commit transaction with epoch = %d, commitmentToSend = %v", epoch, commitmentToSend) txn, err := voteManagerUtils.Commit(client, txnOpts, epoch, commitmentToSend) if err != nil { @@ -179,14 +181,14 @@ func (*UtilsStruct) Commit(client *ethclient.Client, config types.Configurations return txnHash, nil } -func CalculateSeed(client *ethclient.Client, account types.Account, keystorePath string, epoch uint32) ([]byte, error) { +func CalculateSeed(rpcParameters rpc.RPCParameters, account types.Account, keystorePath string, epoch uint32) ([]byte, error) { log.Debugf("CalculateSeed: Calling CalculateSecret() with arguments epoch = %d, keystorePath = %s, chainId = %s", epoch, keystorePath, core.ChainId) _, secret, err := cmdUtils.CalculateSecret(account, epoch, keystorePath, core.ChainId) if err != nil { return nil, err } log.Debugf("CalculateSeed: Getting Salt for current epoch %d...", epoch) - salt, err := cmdUtils.GetSalt(client, epoch) + salt, err := cmdUtils.GetSalt(rpcParameters, epoch) if err != nil { log.Error("Error in getting salt: ", err) return nil, err @@ -214,31 +216,79 @@ func CalculateCommitment(seed []byte, values []*big.Int) ([32]byte, error) { return commitmentToSend, nil } -func VerifyCommitment(client *ethclient.Client, account types.Account, keystorePath string, epoch uint32, values []*big.Int) (bool, error) { - commitmentStruct, err := razorUtils.GetCommitment(client, account.Address) +func VerifyCommitment(rpcParameters rpc.RPCParameters, account types.Account, commitmentFetched [32]byte) (bool, error) { + commitmentStruct, err := razorUtils.GetCommitment(rpcParameters, account.Address) if err != nil { log.Error("Error in getting commitments: ", err) return false, err } log.Debugf("VerifyCommitment: CommitmentStruct: %+v", commitmentStruct) - seed, err := CalculateSeed(client, account, keystorePath, epoch) - if err != nil { - log.Error("Error in calculating seed: ", err) - return false, err + if commitmentFetched == commitmentStruct.CommitmentHash { + log.Debug("VerifyCommitment: Commitment fetched from memory/file system for given values is EQUAL to commitment of the epoch") + return true, nil + } + log.Debug("VerifyCommitment: Commitment fetched from memory/file system for given values DOES NOT MATCH with commitment in the epoch") + return false, nil +} + +func GetCommittedDataForEpoch(rpcParameters rpc.RPCParameters, account types.Account, epoch uint32, rogueData types.Rogue) (types.CommitFileData, error) { + // Attempt to fetch global commit data from memory if epoch matches + if globalCommitDataStruct.Epoch == epoch { + log.Debugf("Epoch in global commit data is equal to current epoch %v. Fetching commit data from memory!", epoch) + } else { + // Fetch from file if memory data is outdated + log.Debugf("GetCommittedDataForEpoch: Global commit data epoch %v doesn't match current epoch %v. Fetching from file!", globalCommitDataStruct.Epoch, epoch) + log.Info("Getting the commit data from file...") + fileName, err := pathUtils.GetCommitDataFileName(account.Address) + if err != nil { + return types.CommitFileData{}, err + } + + log.Debug("GetCommittedDataForEpoch: Commit data file path: ", fileName) + commitDataFromFile, err := fileUtils.ReadFromCommitJsonFile(fileName) + if err != nil { + return types.CommitFileData{}, err + } + + log.Debug("GetCommittedDataForEpoch: Committed data from file: ", commitDataFromFile) + if commitDataFromFile.Epoch != epoch { + log.Errorf("File %s doesn't contain latest committed data", fileName) + return types.CommitFileData{}, errors.New("commit data file doesn't contain latest committed data") + } + + // Update global commit data struct since the file data is valid + updateGlobalCommitDataStruct(types.CommitData{ + Leaves: commitDataFromFile.Leaves, + SeqAllottedCollections: commitDataFromFile.SeqAllottedCollections, + AssignedCollections: commitDataFromFile.AssignedCollections, + }, commitDataFromFile.Commitment, epoch) } - calculatedCommitment, err := CalculateCommitment(seed, values) + // Verify the final selected commit data + log.Debugf("Verifying commit data for epoch %v...", epoch) + isValid, err := VerifyCommitment(rpcParameters, account, globalCommitDataStruct.Commitment) if err != nil { - log.Error("Error in calculating commitment for given committed values: ", err) - return false, err + return types.CommitFileData{}, err + } + if !isValid { + return types.CommitFileData{}, errors.New("commitment verification failed for selected commit data") } - log.Debug("VerifyCommitment: Calculated commitment: ", calculatedCommitment) - if calculatedCommitment == commitmentStruct.CommitmentHash { - log.Debug("VerifyCommitment: Calculated commitment for given values is EQUAL to commitment of the epoch") - return true, nil + // If rogue mode is enabled, alter the commitment data + if rogueData.IsRogue && utils.Contains(rogueData.RogueMode, "reveal") { + log.Warn("YOU ARE REVEALING VALUES IN ROGUE MODE, THIS CAN INCUR PENALTIES!") + globalCommitDataStruct.Leaves = generateRogueCommittedData(len(globalCommitDataStruct.Leaves)) + log.Debugf("Global Commit data struct in rogue mode: %+v", globalCommitDataStruct) } - log.Debug("VerifyCommitment: Calculated commitment for given values DOES NOT MATCH with commitment in the epoch") - return false, nil + + return globalCommitDataStruct, nil +} + +func generateRogueCommittedData(length int) []*big.Int { + var rogueCommittedData []*big.Int + for i := 0; i < length; i++ { + rogueCommittedData = append(rogueCommittedData, razorUtils.GetRogueRandomValue(10000000)) + } + return rogueCommittedData } diff --git a/cmd/commit_test.go b/cmd/commit_test.go index a998ec22d..8951f0890 100644 --- a/cmd/commit_test.go +++ b/cmd/commit_test.go @@ -6,7 +6,6 @@ import ( "fmt" "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/mock" "math/big" "razor/cache" @@ -20,21 +19,21 @@ import ( func TestCommit(t *testing.T) { var ( - client *ethclient.Client account types.Account config types.Configurations latestHeader *Types.Header - seed []byte + stateBuffer uint64 epoch uint32 + commitment [32]byte ) type args struct { - values []*big.Int - state int64 - stateErr error - commitTxn *Types.Transaction - commitErr error - hash common.Hash + state int64 + stateErr error + txnOptsErr error + commitTxn *Types.Transaction + commitErr error + hash common.Hash } tests := []struct { name string @@ -45,7 +44,6 @@ func TestCommit(t *testing.T) { { name: "Test 1: When Commit function executes successfully", args: args{ - values: []*big.Int{big.NewInt(1)}, state: 0, stateErr: nil, commitTxn: &Types.Transaction{}, @@ -58,7 +56,6 @@ func TestCommit(t *testing.T) { { name: "Test 2: When there is an error in getting state", args: args{ - values: []*big.Int{big.NewInt(1)}, stateErr: errors.New("state error"), commitTxn: &Types.Transaction{}, commitErr: nil, @@ -70,7 +67,6 @@ func TestCommit(t *testing.T) { { name: "Test 3: When Commit transaction fails", args: args{ - values: []*big.Int{big.NewInt(1)}, state: 0, stateErr: nil, commitTxn: &Types.Transaction{}, @@ -81,28 +77,26 @@ func TestCommit(t *testing.T) { wantErr: errors.New("commit error"), }, { - name: "Test 4: When there is an error in getting commitmentHashString as values is nil", + name: "Test 4: When there is an error in getting txnOpts", args: args{ - values: []*big.Int{}, + state: 0, + txnOptsErr: errors.New("txnOpts error"), }, want: core.NilHash, - wantErr: errors.New("Error in getting merkle tree: values are nil, cannot create merkle tree"), + wantErr: errors.New("txnOpts error"), }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utils.MerkleInterface = &utils.MerkleTreeStruct{} - merkleUtils = utils.MerkleInterface - - utilsMock.On("GetBufferedState", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything).Return(tt.args.state, tt.args.stateErr) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetBufferedState", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.state, tt.args.stateErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) voteManagerMock.On("Commit", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.TransactOpts"), mock.AnythingOfType("uint32"), mock.Anything).Return(tt.args.commitTxn, tt.args.commitErr) transactionMock.On("Hash", mock.AnythingOfType("*types.Transaction")).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.Commit(client, config, account, epoch, latestHeader, seed, tt.args.values) + got, err := utils.Commit(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitment) if got != tt.want { t.Errorf("Txn hash for Commit function, got = %v, want = %v", got, tt.want) } @@ -121,9 +115,8 @@ func TestCommit(t *testing.T) { func TestHandleCommitState(t *testing.T) { var ( - client *ethclient.Client - epoch uint32 - seed []byte + epoch uint32 + seed []byte ) rogueValue := big.NewInt(1111) @@ -232,14 +225,14 @@ func TestHandleCommitState(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetNumActiveCollections", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.numActiveCollections, tt.args.numActiveCollectionsErr) - utilsMock.On("GetAssignedCollections", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything).Return(tt.args.assignedCollections, tt.args.seqAllottedCollections, tt.args.assignedCollectionsErr) - utilsMock.On("GetCollectionIdFromIndex", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.collectionId, tt.args.collectionIdErr) - utilsMock.On("GetAggregatedDataOfCollection", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.collectionData, tt.args.collectionDataErr) + utilsMock.On("GetNumActiveCollections", mock.Anything).Return(tt.args.numActiveCollections, tt.args.numActiveCollectionsErr) + utilsMock.On("GetAssignedCollections", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.assignedCollections, tt.args.seqAllottedCollections, tt.args.assignedCollectionsErr) + utilsMock.On("GetCollectionIdFromIndex", mock.Anything, mock.Anything).Return(tt.args.collectionId, tt.args.collectionIdErr) + utilsMock.On("GetAggregatedDataOfCollection", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.collectionData, tt.args.collectionDataErr) utilsMock.On("GetRogueRandomValue", mock.Anything).Return(rogueValue) utils := &UtilsStruct{} - got, err := utils.HandleCommitState(client, epoch, seed, commitParams, tt.args.rogueData) + got, err := utils.HandleCommitState(rpcParameters, epoch, seed, commitParams, tt.args.rogueData) if !reflect.DeepEqual(got, tt.want) { t.Errorf("Data from HandleCommitState function, got = %v, want = %v", got, tt.want) } @@ -258,8 +251,6 @@ func TestHandleCommitState(t *testing.T) { } func TestGetSalt(t *testing.T) { - var client *ethclient.Client - type args struct { epoch uint32 numProposedBlocks uint8 @@ -350,15 +341,15 @@ func TestGetSalt(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetNumberOfProposedBlocks", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.numProposedBlocks, tt.args.numProposedBlocksErr) - utilsMock.On("GetBlockIndexToBeConfirmed", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.blockIndexedToBeConfirmed, tt.args.blockIndexedToBeConfirmedErr) - voteManagerUtilsMock.On("GetSaltFromBlockchain", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.saltFromBlockChain, tt.args.saltFromBlockChainErr) - utilsMock.On("GetSortedProposedBlockId", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything).Return(tt.args.blockId, tt.args.blockIdErr) - utilsMock.On("GetProposedBlock", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything).Return(tt.args.previousBlock, tt.args.previousBlockErr) + utilsMock.On("GetNumberOfProposedBlocks", mock.Anything, mock.Anything).Return(tt.args.numProposedBlocks, tt.args.numProposedBlocksErr) + utilsMock.On("GetBlockIndexToBeConfirmed", mock.Anything).Return(tt.args.blockIndexedToBeConfirmed, tt.args.blockIndexedToBeConfirmedErr) + utilsMock.On("GetSaltFromBlockchain", mock.Anything).Return(tt.args.saltFromBlockChain, tt.args.saltFromBlockChainErr) + utilsMock.On("GetSortedProposedBlockId", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.blockId, tt.args.blockIdErr) + utilsMock.On("GetProposedBlock", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.previousBlock, tt.args.previousBlockErr) utilsMock.On("CalculateSalt", mock.Anything, mock.Anything).Return(tt.args.salt) ut := &UtilsStruct{} - got, err := ut.GetSalt(client, tt.args.epoch) + got, err := ut.GetSalt(rpcParameters, tt.args.epoch) if !reflect.DeepEqual(got, tt.want) { t.Errorf("Data from GetSalt function, got = %v, want = %v", got, tt.want) } @@ -377,9 +368,8 @@ func TestGetSalt(t *testing.T) { func BenchmarkHandleCommitState(b *testing.B) { var ( - client *ethclient.Client - epoch uint32 - seed []byte + epoch uint32 + seed []byte ) rogueValue := big.NewInt(1111) @@ -402,14 +392,14 @@ func BenchmarkHandleCommitState(b *testing.B) { SetUpMockInterfaces() - utilsMock.On("GetNumActiveCollections", mock.AnythingOfType("*ethclient.Client")).Return(v.numActiveCollections, nil) - utilsMock.On("GetAssignedCollections", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything).Return(v.assignedCollections, nil, nil) - utilsMock.On("GetCollectionIdFromIndex", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(uint16(1), nil) - utilsMock.On("GetAggregatedDataOfCollection", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(big.NewInt(1000), nil) + utilsMock.On("GetNumActiveCollections", mock.Anything).Return(v.numActiveCollections, nil) + utilsMock.On("GetAssignedCollections", mock.Anything, mock.Anything, mock.Anything).Return(v.assignedCollections, nil, nil) + utilsMock.On("GetCollectionIdFromIndex", mock.Anything, mock.Anything).Return(uint16(1), nil) + utilsMock.On("GetAggregatedDataOfCollection", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(big.NewInt(1000), nil) utilsMock.On("GetRogueRandomValue", mock.Anything).Return(rogueValue) ut := &UtilsStruct{} - _, err := ut.HandleCommitState(client, epoch, seed, commitParams, types.Rogue{IsRogue: false}) + _, err := ut.HandleCommitState(rpcParameters, epoch, seed, commitParams, types.Rogue{IsRogue: false}) if err != nil { log.Fatal(err) } @@ -490,18 +480,12 @@ func TestCalculateCommitment(t *testing.T) { func TestVerifyCommitment(t *testing.T) { var ( - client *ethclient.Client - account types.Account - keystorePath string - epoch uint32 + account types.Account ) type args struct { - values []*big.Int - commitmentHashString string - commitmentErr error - secret string - secretErr error - salt string + commitmentFetchedString string + commitmentHashString string + commitmentErr error } tests := []struct { name string @@ -510,82 +494,53 @@ func TestVerifyCommitment(t *testing.T) { wantErr bool }{ { - name: "Test 1: When commitmentHashString is verified successfully", + name: "Test 1: When commitmentFetched matches the commitment in the epoch", args: args{ - commitmentHashString: "22c9ba074e44d0009116b244a5cece9e9ade85af486e1f4f8db8e304e6605bea", - values: []*big.Int{big.NewInt(200), big.NewInt(100)}, - salt: "03bceb412a8c973dbb960f1353ba91cf6ca10dfde21c911054cf1e61f0d28e0b", - secret: "0f7f6290794dae00bf7c673d36fa2a5b447d2c8c60e9a4220b7ab65be80547a9", + commitmentHashString: "22c9ba074e44d0009116b244a5cece9e9ade85af486e1f4f8db8e304e6605bea", + commitmentFetchedString: "22c9ba074e44d0009116b244a5cece9e9ade85af486e1f4f8db8e304e6605bea", }, want: true, wantErr: false, }, { - name: "Test 2: When commitmentHashString is not verified successfully", + name: "Test 2: When commitmentFetched does not match the commitment in the epoch", args: args{ - commitmentHashString: "23cabb074e44d0009116b244a5cece9e9ade85af486e1f4f8db8e304e6605bea", - values: []*big.Int{big.NewInt(200), big.NewInt(100)}, - salt: "03bceb412a8c973dbb960f1353ba91cf6ca10dfde21c911054cf1e61f0d28e0b", - secret: "0f7f6290794dae00bf7c673d36fa2a5b447d2c8c60e9a4220b7ab65be80547a9", + commitmentHashString: "23cabb074e44d0009116b244a5cece9e9ade85af486e1f4f8db8e304e6605bea", + commitmentFetchedString: "22c9ba074e44d0009116b244a5cece9e9ade85af486e1f4f8db8e304e6605bea", }, want: false, wantErr: false, }, { - name: "Test 3: When there is an error in getting commitmentHashString", + name: "Test 3: When there is an error in fetching commitment from the blockchain", args: args{ commitmentErr: errors.New("getCommitment error"), }, want: false, wantErr: true, }, - { - name: "Test 4: When there is error in calculating commitmentHashString", - args: args{ - commitmentHashString: "22c9ba074e44d0009116b244a5cece9e9ade85af486e1f4f8db8e304e6605bea", - values: []*big.Int{}, - }, - want: false, - wantErr: true, - }, - { - name: "Test 5: When there is error in calculating seed", - args: args{ - commitmentHashString: "22c9ba074e44d0009116b244a5cece9e9ade85af486e1f4f8db8e304e6605bea", - values: []*big.Int{big.NewInt(200), big.NewInt(100)}, - secretErr: errors.New("secret error"), - }, - want: false, - wantErr: true, - }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var commitmentHash [32]byte - var salt [32]byte - var secret []byte + var commitmentFetched [32]byte - if tt.args.commitmentHashString != "" { - var err error - commitmentHash, err = convertStringToByte32(tt.args.commitmentHashString) - if err != nil { - t.Errorf("Error in decoding commitmentHashString: %v", err) - return - } - } - if tt.args.secret != "" { + // Convert the commitmentFetchedString to a [32]byte format + if tt.args.commitmentFetchedString != "" { var err error - secret, err = hex.DecodeString(tt.args.secret) + commitmentFetched, err = convertStringToByte32(tt.args.commitmentFetchedString) if err != nil { - t.Errorf("Error in decoding secret: %v", err) + t.Errorf("Error in decoding commitmentFetchedString: %v", err) return } } - if tt.args.salt != "" { + + // Convert the commitmentHashString to a [32]byte format + if tt.args.commitmentHashString != "" { var err error - salt, err = convertStringToByte32(tt.args.salt) + commitmentHash, err = convertStringToByte32(tt.args.commitmentHashString) if err != nil { - t.Errorf("Error in decoding salt: %v", err) + t.Errorf("Error in decoding commitmentHashString: %v", err) return } } @@ -596,9 +551,8 @@ func TestVerifyCommitment(t *testing.T) { merkleUtils = utils.MerkleInterface utilsMock.On("GetCommitment", mock.Anything, mock.Anything).Return(types.Commitment{CommitmentHash: commitmentHash}, tt.args.commitmentErr) - cmdUtilsMock.On("GetSalt", mock.Anything, mock.Anything).Return(salt, nil) - cmdUtilsMock.On("CalculateSecret", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, secret, tt.args.secretErr) - got, err := VerifyCommitment(client, account, keystorePath, epoch, tt.args.values) + + got, err := VerifyCommitment(rpcParameters, account, commitmentFetched) if (err != nil) != tt.wantErr { t.Errorf("VerifyCommitment() error = %v, wantErr %v", err, tt.wantErr) return @@ -612,7 +566,6 @@ func TestVerifyCommitment(t *testing.T) { func TestCalculateSeed(t *testing.T) { var ( - client *ethclient.Client account types.Account keystorePath string epoch uint32 @@ -682,7 +635,7 @@ func TestCalculateSeed(t *testing.T) { cmdUtilsMock.On("CalculateSecret", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, secret, tt.args.secretErr) cmdUtilsMock.On("GetSalt", mock.Anything, mock.Anything).Return(salt, tt.args.saltErr) - got, err := CalculateSeed(client, account, keystorePath, epoch) + got, err := CalculateSeed(rpcParameters, account, keystorePath, epoch) if (err != nil) != tt.wantErr { t.Errorf("CalculateSeed() error = %v, wantErr %v", err, tt.wantErr) return diff --git a/cmd/config-utils.go b/cmd/config-utils.go index 2220e8bcf..9335090d3 100644 --- a/cmd/config-utils.go +++ b/cmd/config-utils.go @@ -3,14 +3,14 @@ package cmd import ( "errors" - "github.com/ethereum/go-ethereum/ethclient" - "github.com/sirupsen/logrus" - "razor/client" "razor/core" "razor/core/types" + "razor/rpc" "razor/utils" "strings" + "github.com/sirupsen/logrus" + "github.com/spf13/viper" ) @@ -18,7 +18,6 @@ import ( func (*UtilsStruct) GetConfigData() (types.Configurations, error) { config := types.Configurations{ Provider: "", - AlternateProvider: "", GasMultiplier: 0, BufferPercent: 0, WaitTime: 0, @@ -35,10 +34,6 @@ func (*UtilsStruct) GetConfigData() (types.Configurations, error) { if err != nil { return config, err } - alternateProvider, err := cmdUtils.GetAlternateProvider() - if err != nil { - return config, err - } gasMultiplier, err := cmdUtils.GetMultiplier() if err != nil { return config, err @@ -88,8 +83,6 @@ func (*UtilsStruct) GetConfigData() (types.Configurations, error) { return config, err } config.Provider = provider - config.AlternateProvider = alternateProvider - client.SetAlternateProvider(alternateProvider) config.GasMultiplier = gasMultiplier config.BufferPercent = bufferPercent config.WaitTime = waitTime @@ -170,19 +163,6 @@ func (*UtilsStruct) GetProvider() (string, error) { return providerString, nil } -//This function returns the alternate provider -func (*UtilsStruct) GetAlternateProvider() (string, error) { - alternateProvider, err := getConfigValue("alternateProvider", "string", "", "alternateProvider") - if err != nil { - return "", err - } - alternateProviderString := alternateProvider.(string) - if !strings.HasPrefix(alternateProviderString, "https") { - log.Warn("You are not using a secure RPC URL. Switch to an https URL instead to be safe.") - } - return alternateProviderString, nil -} - //This function returns the multiplier func (*UtilsStruct) GetMultiplier() (float32, error) { const ( @@ -228,7 +208,7 @@ func (*UtilsStruct) GetBufferPercent() (int32, error) { func (*UtilsStruct) GetWaitTime() (int32, error) { const ( MinWaitTime = 1 // Minimum wait time in seconds - MaxWaitTime = 30 // Maximum wait time in seconds + MaxWaitTime = 15 // Maximum wait time in seconds ) waitTime, err := getConfigValue("wait", "int32", core.DefaultWaitTime, "wait") @@ -323,7 +303,7 @@ func (*UtilsStruct) GetGasLimitOverride() (uint64, error) { //This function returns the RPC timeout func (*UtilsStruct) GetRPCTimeout() (int64, error) { const ( - MinRPCTimeout = 5 // Minimum RPC timeout in seconds + MinRPCTimeout = 1 // Minimum RPC timeout in seconds MaxRPCTimeout = 10 // Maximum RPC timeout in seconds ) @@ -345,7 +325,7 @@ func (*UtilsStruct) GetRPCTimeout() (int64, error) { func (*UtilsStruct) GetHTTPTimeout() (int64, error) { const ( - MinHTTPTimeout = 5 // Minimum HTTP timeout in seconds + MinHTTPTimeout = 3 // Minimum HTTP timeout in seconds MaxHTTPTimeout = 8 // Maximum HTTP timeout in seconds ) @@ -392,11 +372,9 @@ func (*UtilsStruct) GetLogFileMaxAge() (int, error) { //This function sets the log level func setLogLevel(config types.Configurations) { if config.LogLevel == "debug" { - log.SetLevel(logrus.DebugLevel) + log.SetLogLevel(logrus.DebugLevel) } - log.Debugf("Config details: %+v", config) - if razorUtils.IsFlagPassed("logFile") { log.Debugf("Log File Max Size: %d MB", config.LogFileMaxSize) log.Debugf("Log File Max Backups (max number of old log files to retain): %d", config.LogFileMaxBackups) @@ -404,8 +382,8 @@ func setLogLevel(config types.Configurations) { } } -func ValidateBufferPercentLimit(client *ethclient.Client, bufferPercent int32) error { - stateBuffer, err := razorUtils.GetStateBuffer(client) +func ValidateBufferPercentLimit(rpcParameters rpc.RPCParameters, bufferPercent int32) error { + stateBuffer, err := razorUtils.GetStateBuffer(rpcParameters) if err != nil { return err } diff --git a/cmd/config-utils_test.go b/cmd/config-utils_test.go index 6bea01ba7..92f8a70b5 100644 --- a/cmd/config-utils_test.go +++ b/cmd/config-utils_test.go @@ -2,7 +2,6 @@ package cmd import ( "errors" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/viper" "github.com/stretchr/testify/mock" "os" @@ -38,7 +37,6 @@ func removeTestConfig(path string) { func TestGetConfigData(t *testing.T) { nilConfig := types.Configurations{ Provider: "", - AlternateProvider: "", GasMultiplier: 0, BufferPercent: 0, WaitTime: 0, @@ -53,7 +51,6 @@ func TestGetConfigData(t *testing.T) { configData := types.Configurations{ Provider: "", - AlternateProvider: "", GasMultiplier: 1, BufferPercent: 20, WaitTime: 1, @@ -70,8 +67,6 @@ func TestGetConfigData(t *testing.T) { type args struct { provider string providerErr error - alternateProvider string - alternateProviderErr error gasMultiplier float32 gasMultiplierErr error bufferPercent int32 @@ -107,7 +102,6 @@ func TestGetConfigData(t *testing.T) { name: "Test 1: When GetConfigData function executes successfully", args: args{ provider: "", - alternateProvider: "", gasMultiplier: 1, bufferPercent: 20, waitTime: 1, @@ -195,21 +189,12 @@ func TestGetConfigData(t *testing.T) { want: nilConfig, wantErr: errors.New("httpTimeout error"), }, - { - name: "Test 11: When there is an error in getting alternate provider", - args: args{ - alternateProviderErr: errors.New("alternate provider error"), - }, - want: nilConfig, - wantErr: errors.New("alternate provider error"), - }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() cmdUtilsMock.On("GetProvider").Return(tt.args.provider, tt.args.providerErr) - cmdUtilsMock.On("GetAlternateProvider").Return(tt.args.alternateProvider, tt.args.alternateProviderErr) cmdUtilsMock.On("GetMultiplier").Return(tt.args.gasMultiplier, tt.args.gasMultiplierErr) cmdUtilsMock.On("GetWaitTime").Return(tt.args.waitTime, tt.args.waitTimeErr) cmdUtilsMock.On("GetGasPrice").Return(tt.args.gasPrice, tt.args.gasPriceErr) @@ -849,94 +834,6 @@ func TestGetProvider(t *testing.T) { } } -func TestGetAlternateProvider(t *testing.T) { - type args struct { - isFlagSet bool - alternateProvider string - alternateProviderErr error - alternateProviderInConfig string - } - tests := []struct { - name string - useDummyConfigFile bool - args args - want string - wantErr error - }{ - { - name: "Test 1: When alternateProvider is fetched from root flag", - args: args{ - isFlagSet: true, - alternateProvider: "https://polygon-mumbai.g.alchemy.com/v2/-Re1lE3oDIVTWchuKMfRIECn0I", - }, - want: "https://polygon-mumbai.g.alchemy.com/v2/-Re1lE3oDIVTWchuKMfRIECn0I", - wantErr: nil, - }, - { - name: "Test 2: When alternateProvider from root flag has prefix https", - args: args{ - isFlagSet: true, - alternateProvider: "127.0.0.1:8545", - }, - want: "127.0.0.1:8545", - wantErr: nil, - }, - { - name: "Test 3: When there is an error in fetching alternateProvider from root flag", - args: args{ - isFlagSet: true, - alternateProviderErr: errors.New("alternateProvider error"), - }, - want: "", - wantErr: errors.New("alternateProvider error"), - }, - { - name: "Test 4: When alternateProvider value is fetched from config", - useDummyConfigFile: true, - args: args{ - alternateProviderInConfig: "https://some-config-provider.com", - }, - want: "https://some-config-provider.com", - wantErr: nil, - }, - { - name: "Test 5: When alternateProvider is not passed in root nor set in config", - want: "", - wantErr: nil, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - viper.Reset() // Reset viper state - - if tt.useDummyConfigFile { - createTestConfig(t, "alternateProvider", tt.args.alternateProviderInConfig) - defer removeTestConfig(tempConfigPath) - } - - SetUpMockInterfaces() - - flagSetMock.On("FetchRootFlagInput", mock.Anything, mock.Anything).Return(tt.args.alternateProvider, tt.args.alternateProviderErr) - flagSetMock.On("Changed", mock.Anything, mock.Anything).Return(tt.args.isFlagSet) - - utils := &UtilsStruct{} - got, err := utils.GetAlternateProvider() - if got != tt.want { - t.Errorf("getAlternateProvider() got = %v, want %v", got, tt.want) - } - if err == nil || tt.wantErr == nil { - if err != tt.wantErr { - t.Errorf("Error for getAlternateProvider function, got = %v, want = %v", err, tt.wantErr) - } - } else { - if err.Error() != tt.wantErr.Error() { - t.Errorf("Error for getAlternateProvider function, got = %v, want = %v", err, tt.wantErr) - } - } - }) - } -} - func TestGetRPCTimeout(t *testing.T) { type args struct { isFlagSet bool @@ -1202,8 +1099,6 @@ func TestGetWaitTime(t *testing.T) { } func TestValidateBufferPercentLimit(t *testing.T) { - var client *ethclient.Client - type args struct { bufferPercent int32 stateBuffer uint64 @@ -1245,7 +1140,7 @@ func TestValidateBufferPercentLimit(t *testing.T) { utilsMock.On("GetStateBuffer", mock.Anything).Return(tt.args.stateBuffer, tt.args.stateBufferErr) - err := ValidateBufferPercentLimit(client, tt.args.bufferPercent) + err := ValidateBufferPercentLimit(rpcParameters, tt.args.bufferPercent) if err == nil || tt.wantErr == nil { if err != tt.wantErr { t.Errorf("Error for GetEpochAndState function, got = %v, want = %v", err, tt.wantErr) diff --git a/cmd/confirm.go b/cmd/confirm.go index e9d308b04..7f4e04137 100644 --- a/cmd/confirm.go +++ b/cmd/confirm.go @@ -4,20 +4,21 @@ package cmd import ( "razor/core" "razor/core/types" + "razor/rpc" "github.com/ethereum/go-ethereum/common" ) //This function allows the user to claim the block reward and returns the hash -func (*UtilsStruct) ClaimBlockReward(options types.TransactionOptions) (common.Hash, error) { - epoch, err := razorUtils.GetEpoch(options.Client) +func (*UtilsStruct) ClaimBlockReward(rpcParameters rpc.RPCParameters, options types.TransactionOptions) (common.Hash, error) { + epoch, err := razorUtils.GetEpoch(rpcParameters) if err != nil { log.Error("Error in getting epoch: ", err) return core.NilHash, err } log.Debug("ClaimBlockReward: Epoch: ", epoch) - sortedProposedBlockIds, err := razorUtils.GetSortedProposedBlockIds(options.Client, epoch) + sortedProposedBlockIds, err := razorUtils.GetSortedProposedBlockIds(rpcParameters, epoch) if err != nil { log.Error("Error in getting sortedProposedBlockIds: ", err) return core.NilHash, err @@ -29,14 +30,14 @@ func (*UtilsStruct) ClaimBlockReward(options types.TransactionOptions) (common.H return core.NilHash, nil } - stakerID, err := razorUtils.GetStakerId(options.Client, options.Account.Address) + stakerID, err := razorUtils.GetStakerId(rpcParameters, options.Account.Address) if err != nil { log.Error("Error in getting stakerId: ", err) return core.NilHash, err } log.Debug("ClaimBlockReward: Staker Id: ", stakerID) - selectedProposedBlock, err := razorUtils.GetProposedBlock(options.Client, epoch, sortedProposedBlockIds[0]) + selectedProposedBlock, err := razorUtils.GetProposedBlock(rpcParameters, epoch, sortedProposedBlockIds[0]) if err != nil { log.Error("Error in getting selectedProposedBlock: ", err) return core.NilHash, err @@ -45,9 +46,18 @@ func (*UtilsStruct) ClaimBlockReward(options types.TransactionOptions) (common.H if selectedProposedBlock.ProposerId == stakerID { log.Info("Claiming block reward...") - txnOpts := razorUtils.GetTxnOpts(options) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, options) + if err != nil { + return core.NilHash, err + } + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debug("Executing ClaimBlockReward transaction...") - txn, err := blockManagerUtils.ClaimBlockReward(options.Client, txnOpts) + txn, err := blockManagerUtils.ClaimBlockReward(client, txnOpts) if err != nil { log.Error("Error in claiming block reward: ", err) return core.NilHash, err diff --git a/cmd/confirm_test.go b/cmd/confirm_test.go index cd7977f1a..d72b463b2 100644 --- a/cmd/confirm_test.go +++ b/cmd/confirm_test.go @@ -2,13 +2,14 @@ package cmd import ( "errors" - "github.com/stretchr/testify/mock" "math/big" "razor/core" "razor/core/types" "razor/pkg/bindings" "testing" + "github.com/stretchr/testify/mock" + "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" ) @@ -25,6 +26,7 @@ func TestClaimBlockReward(t *testing.T) { sortedProposedBlockIdsErr error selectedBlock bindings.StructsBlock selectedBlockErr error + txnOptsErr error ClaimBlockRewardTxn *Types.Transaction ClaimBlockRewardErr error hash common.Hash @@ -124,21 +126,33 @@ func TestClaimBlockReward(t *testing.T) { want: core.NilHash, wantErr: nil, }, + { + name: "Test 9: When there is an error in getting txnOpts", + args: args{ + epoch: 5, + stakerId: 2, + sortedProposedBlockIds: []uint32{2, 1, 3}, + selectedBlock: bindings.StructsBlock{ProposerId: 2}, + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetEpoch", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epoch, tt.args.epochErr) - utilsMock.On("GetSortedProposedBlockIds", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.sortedProposedBlockIds, tt.args.sortedProposedBlockIdsErr) - utilsMock.On("GetStakerId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.stakerId, tt.args.stakerIdErr) - utilsMock.On("GetProposedBlock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(tt.args.selectedBlock, tt.args.selectedBlockErr) - utilsMock.On("GetTxnOpts", options).Return(TxnOpts) + utilsMock.On("GetEpoch", mock.Anything).Return(tt.args.epoch, tt.args.epochErr) + utilsMock.On("GetSortedProposedBlockIds", mock.Anything, mock.Anything).Return(tt.args.sortedProposedBlockIds, tt.args.sortedProposedBlockIdsErr) + utilsMock.On("GetStakerId", mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) + utilsMock.On("GetProposedBlock", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.selectedBlock, tt.args.selectedBlockErr) + utilsMock.On("GetTxnOpts", mock.Anything, options).Return(TxnOpts, tt.args.txnOptsErr) blockManagerMock.On("ClaimBlockReward", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.TransactOpts")).Return(tt.args.ClaimBlockRewardTxn, tt.args.ClaimBlockRewardErr) transactionMock.On("Hash", mock.AnythingOfType("*types.Transaction")).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.ClaimBlockReward(options) + got, err := utils.ClaimBlockReward(rpcParameters, options) if got != tt.want { t.Errorf("Txn hash for ClaimBlockReward function, got = %v, want = %v", got, tt.want) } diff --git a/cmd/contractAddresses.go b/cmd/contractAddresses.go index fd5cfadb1..b3878b7cb 100644 --- a/cmd/contractAddresses.go +++ b/cmd/contractAddresses.go @@ -25,10 +25,9 @@ func initialiseContractAddresses(cmd *cobra.Command, args []string) { //This function sets the flag appropriatley and executes the ContractAddresses function func (*UtilsStruct) ExecuteContractAddresses(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) + _, _, _, _, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) + fmt.Println("The contract addresses are: ") cmdUtils.ContractAddresses() diff --git a/cmd/contractAddresses_test.go b/cmd/contractAddresses_test.go index 0deedd25c..7834b06e9 100644 --- a/cmd/contractAddresses_test.go +++ b/cmd/contractAddresses_test.go @@ -35,13 +35,15 @@ func TestExecuteContractAddresses(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(false) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(types.Configurations{}, nil) cmdUtilsMock.On("ContractAddresses") diff --git a/cmd/createCollection.go b/cmd/createCollection.go index d6c44cd93..6c27c1e9e 100644 --- a/cmd/createCollection.go +++ b/cmd/createCollection.go @@ -2,15 +2,13 @@ package cmd import ( - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/cobra" "github.com/spf13/pflag" ) @@ -36,29 +34,8 @@ func initialiseCreateCollection(cmd *cobra.Command, args []string) { //This function sets the flags appropriately and executes the CreateCollection function func (*UtilsStruct) ExecuteCreateCollection(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteCreateCollection: Config: %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - - logger.SetLoggerParameters(client, address) - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) name, err := flagSetUtils.GetStringName(flagSet) utils.CheckError("Error in getting name: ", err) @@ -84,23 +61,22 @@ func (*UtilsStruct) ExecuteCreateCollection(flagSet *pflag.FlagSet) { Account: account, } - txn, err := cmdUtils.CreateCollection(client, config, collectionInput) + txn, err := cmdUtils.CreateCollection(rpcParameters, config, collectionInput) utils.CheckError("CreateCollection error: ", err) - err = razorUtils.WaitForBlockCompletion(client, txn.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txn.Hex()) utils.CheckError("Error in WaitForBlockCompletion for createCollection: ", err) } //This function allows the admin to create collction if existing jobs are present -func (*UtilsStruct) CreateCollection(client *ethclient.Client, config types.Configurations, collectionInput types.CreateCollectionInput) (common.Hash, error) { +func (*UtilsStruct) CreateCollection(rpcParameters rpc.RPCParameters, config types.Configurations, collectionInput types.CreateCollectionInput) (common.Hash, error) { jobIds := utils.ConvertUintArrayToUint16Array(collectionInput.JobIds) log.Debug("CreateCollection: Uint16 jobIds: ", jobIds) - _, err := cmdUtils.WaitForAppropriateState(client, "create collection", 4) + _, err := cmdUtils.WaitForAppropriateState(rpcParameters, "create collection", 4) if err != nil { log.Error("Error in fetching state") return core.NilHash, err } - txnOpts := razorUtils.GetTxnOpts(types.TransactionOptions{ - Client: client, + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{ ChainId: core.ChainId, Config: config, ContractAddress: core.CollectionManagerAddress, @@ -109,6 +85,15 @@ func (*UtilsStruct) CreateCollection(client *ethclient.Client, config types.Conf ABI: bindings.CollectionManagerMetaData.ABI, Account: collectionInput.Account, }) + if err != nil { + return core.NilHash, err + } + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debugf("Executing CreateCollection transaction with tolerance: %d, power = %d , aggregation = %d, jobIds = %v, name = %s", collectionInput.Tolerance, collectionInput.Power, collectionInput.Aggregation, jobIds, collectionInput.Name) txn, err := assetManagerUtils.CreateCollection(client, txnOpts, collectionInput.Tolerance, collectionInput.Power, collectionInput.Aggregation, jobIds, collectionInput.Name) if err != nil { diff --git a/cmd/createCollection_test.go b/cmd/createCollection_test.go index cb8cfcc08..bdd1568d5 100644 --- a/cmd/createCollection_test.go +++ b/cmd/createCollection_test.go @@ -16,7 +16,6 @@ import ( ) func TestCreateCollection(t *testing.T) { - var client *ethclient.Client var WaitForDisputeOrConfirmStateStatus uint32 var config types.Configurations var collectionInput types.CreateCollectionInput @@ -24,6 +23,7 @@ func TestCreateCollection(t *testing.T) { type args struct { jobIdUint8 []uint16 waitForAppropriateStateErr error + txnOptsErr error createCollectionTxn *Types.Transaction createCollectionErr error hash common.Hash @@ -66,19 +66,28 @@ func TestCreateCollection(t *testing.T) { want: core.NilHash, wantErr: errors.New("createCollection error"), }, + { + name: "Test 4: When there is an error in getting txnOpts", + args: args{ + jobIdUint8: []uint16{1, 2}, + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() utilsMock.On("ConvertUintArrayToUint16Array", mock.Anything).Return(tt.args.jobIdUint8) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) - cmdUtilsMock.On("WaitForAppropriateState", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string"), mock.Anything).Return(WaitForDisputeOrConfirmStateStatus, tt.args.waitForAppropriateStateErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) + cmdUtilsMock.On("WaitForAppropriateState", mock.Anything, mock.Anything, mock.Anything).Return(WaitForDisputeOrConfirmStateStatus, tt.args.waitForAppropriateStateErr) assetManagerMock.On("CreateCollection", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.createCollectionTxn, tt.args.createCollectionErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.CreateCollection(client, config, collectionInput) + got, err := utils.CreateCollection(rpcParameters, config, collectionInput) if got != tt.want { t.Errorf("Txn hash for createCollection function, got = %v, want = %v", got, tt.want) } @@ -265,14 +274,16 @@ func TestExecuteCreateCollection(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("AssignPassword", flagSet).Return(tt.args.password) @@ -285,8 +296,8 @@ func TestExecuteCreateCollection(t *testing.T) { flagSetMock.On("GetInt8Power", flagSet).Return(tt.args.power, tt.args.powerErr) flagSetMock.On("GetUint32Tolerance", flagSet).Return(tt.args.tolerance, tt.args.toleranceErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - cmdUtilsMock.On("CreateCollection", mock.AnythingOfType("*ethclient.Client"), config, mock.Anything).Return(tt.args.createCollectionHash, tt.args.createCollectionErr) - utilsMock.On("WaitForBlockCompletion", client, mock.AnythingOfType("string")).Return(nil) + cmdUtilsMock.On("CreateCollection", mock.Anything, config, mock.Anything).Return(tt.args.createCollectionHash, tt.args.createCollectionErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) utils := &UtilsStruct{} fatal = false diff --git a/cmd/createJob.go b/cmd/createJob.go index df93330cf..36b70896e 100644 --- a/cmd/createJob.go +++ b/cmd/createJob.go @@ -2,15 +2,13 @@ package cmd import ( - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/pflag" "github.com/spf13/cobra" @@ -37,29 +35,8 @@ func initialiseCreateJob(cmd *cobra.Command, args []string) { //This function sets the flags appropriately and executes the CreateJob function func (*UtilsStruct) ExecuteCreateJob(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteCreateJob: Config: %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - - logger.SetLoggerParameters(client, address) - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) name, err := flagSetUtils.GetStringName(flagSet) utils.CheckError("Error in getting name: ", err) @@ -89,16 +66,15 @@ func (*UtilsStruct) ExecuteCreateJob(flagSet *pflag.FlagSet) { Account: account, } - txn, err := cmdUtils.CreateJob(client, config, jobInput) + txn, err := cmdUtils.CreateJob(rpcParameters, config, jobInput) utils.CheckError("CreateJob error: ", err) - err = razorUtils.WaitForBlockCompletion(client, txn.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txn.Hex()) utils.CheckError("Error in WaitForBlockCompletion for createJob: ", err) } //This function allows the admin to create the job -func (*UtilsStruct) CreateJob(client *ethclient.Client, config types.Configurations, jobInput types.CreateJobInput) (common.Hash, error) { +func (*UtilsStruct) CreateJob(rpcParameters rpc.RPCParameters, config types.Configurations, jobInput types.CreateJobInput) (common.Hash, error) { txnArgs := types.TransactionOptions{ - Client: client, ChainId: core.ChainId, Config: config, ContractAddress: core.CollectionManagerAddress, @@ -108,10 +84,19 @@ func (*UtilsStruct) CreateJob(client *ethclient.Client, config types.Configurati Account: jobInput.Account, } - txnOpts := razorUtils.GetTxnOpts(txnArgs) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) + if err != nil { + return core.NilHash, err + } log.Info("Creating Job...") + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debugf("CreateJob: Executing CreateJob transaction with weight = %d, power = %d, selector type = %d, name = %s, selector = %s, URl = %s", jobInput.Weight, jobInput.Power, jobInput.SelectorType, jobInput.Name, jobInput.Selector, jobInput.Url) - txn, err := assetManagerUtils.CreateJob(txnArgs.Client, txnOpts, jobInput.Weight, jobInput.Power, jobInput.SelectorType, jobInput.Name, jobInput.Selector, jobInput.Url) + txn, err := assetManagerUtils.CreateJob(client, txnOpts, jobInput.Weight, jobInput.Power, jobInput.SelectorType, jobInput.Name, jobInput.Selector, jobInput.Url) if err != nil { return core.NilHash, err } diff --git a/cmd/createJob_test.go b/cmd/createJob_test.go index 81bb56119..9f74edee4 100644 --- a/cmd/createJob_test.go +++ b/cmd/createJob_test.go @@ -16,11 +16,11 @@ import ( ) func TestCreateJob(t *testing.T) { - var client *ethclient.Client var jobInput types.CreateJobInput var config types.Configurations type args struct { + txnOptsErr error createJobTxn *Types.Transaction createJobErr error hash common.Hash @@ -50,17 +50,25 @@ func TestCreateJob(t *testing.T) { want: core.NilHash, wantErr: errors.New("createJob error"), }, + { + name: "Test 3: When there is an error in getting txnOpts", + args: args{ + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) assetManagerMock.On("CreateJob", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.TransactOpts"), mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.createJobTxn, tt.args.createJobErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.CreateJob(client, config, jobInput) + got, err := utils.CreateJob(rpcParameters, config, jobInput) if got != tt.want { t.Errorf("Txn hash for createJob function, got = %v, want = %v", got, tt.want) } @@ -287,14 +295,16 @@ func TestExecuteCreateJob(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("AssignPassword", flagSet).Return(tt.args.password) @@ -308,8 +318,8 @@ func TestExecuteCreateJob(t *testing.T) { flagSetMock.On("GetUint8Weight", flagSet).Return(tt.args.weight, tt.args.weightErr) flagSetMock.On("GetUint8SelectorType", flagSet).Return(tt.args.selectorType, tt.args.selectorTypeErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - cmdUtilsMock.On("CreateJob", mock.AnythingOfType("*ethclient.Client"), config, mock.Anything).Return(tt.args.createJobHash, tt.args.createJobErr) - utilsMock.On("WaitForBlockCompletion", client, mock.AnythingOfType("string")).Return(nil) + cmdUtilsMock.On("CreateJob", mock.Anything, config, mock.Anything).Return(tt.args.createJobHash, tt.args.createJobErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) utils := &UtilsStruct{} fatal = false diff --git a/cmd/create_test.go b/cmd/create_test.go index cb7bf36e9..dfcb40752 100644 --- a/cmd/create_test.go +++ b/cmd/create_test.go @@ -148,14 +148,16 @@ func TestExecuteCreate(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(false) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) utilsMock.On("AssignPassword", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.password) utilsMock.On("CheckPassword", mock.Anything).Return(nil) diff --git a/cmd/delegate.go b/cmd/delegate.go index f14ac0b6d..eb8991597 100644 --- a/cmd/delegate.go +++ b/cmd/delegate.go @@ -2,11 +2,10 @@ package cmd import ( - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/common" @@ -33,36 +32,14 @@ func initialiseDelegate(cmd *cobra.Command, args []string) { //This function sets the flags appropriately and executes the Delegate function func (*UtilsStruct) ExecuteDelegate(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteDelegate: Config: %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - log.Debug("ExecuteDelegate: Address: ", address) - - logger.SetLoggerParameters(client, address) - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) stakerId, err := flagSetUtils.GetUint32StakerId(flagSet) utils.CheckError("Error in getting stakerId: ", err) log.Debug("ExecuteDelegate: Staker Id: ", stakerId) - balance, err := razorUtils.FetchBalance(client, address) - utils.CheckError("Error in fetching razor balance for account "+address+": ", err) + balance, err := razorUtils.FetchBalance(rpcParameters, account.Address) + utils.CheckError("Error in fetching razor balance for account "+account.Address+": ", err) log.Debug("ExecuteDelegate: Balance: ", balance) log.Debug("Getting amount in wei...") @@ -72,43 +49,51 @@ func (*UtilsStruct) ExecuteDelegate(flagSet *pflag.FlagSet) { log.Debug("Checking for sufficient balance...") razorUtils.CheckAmountAndBalance(valueInWei, balance) - log.Debug("Checking whether sFuel balance is not 0...") - razorUtils.CheckEthBalanceIsZero(client, address) + log.Debug("Checking whether sFUEL balance is not 0...") + razorUtils.CheckEthBalanceIsZero(rpcParameters, account.Address) txnArgs := types.TransactionOptions{ - Client: client, Amount: valueInWei, ChainId: core.ChainId, Config: config, Account: account, } - approveTxnHash, err := cmdUtils.Approve(txnArgs) + approveTxnHash, err := cmdUtils.Approve(rpcParameters, txnArgs) utils.CheckError("Approve error: ", err) if approveTxnHash != core.NilHash { - err = razorUtils.WaitForBlockCompletion(txnArgs.Client, approveTxnHash.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, approveTxnHash.Hex()) utils.CheckError("Error in WaitForBlockCompletion for approve: ", err) } log.Debug("ExecuteDelegate:Calling Delegate() with stakerId: ", stakerId) - delegateTxnHash, err := cmdUtils.Delegate(txnArgs, stakerId) + delegateTxnHash, err := cmdUtils.Delegate(rpcParameters, txnArgs, stakerId) utils.CheckError("Delegate error: ", err) - err = razorUtils.WaitForBlockCompletion(client, delegateTxnHash.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, delegateTxnHash.Hex()) utils.CheckError("Error in WaitForBlockCompletion for delegate: ", err) } //This function allows the delegator to stake coins without setting up a node -func (*UtilsStruct) Delegate(txnArgs types.TransactionOptions, stakerId uint32) (common.Hash, error) { +func (*UtilsStruct) Delegate(rpcParameters rpc.RPCParameters, txnArgs types.TransactionOptions, stakerId uint32) (common.Hash, error) { log.Infof("Delegating %g razors to Staker %d", utils.GetAmountInDecimal(txnArgs.Amount), stakerId) txnArgs.ContractAddress = core.StakeManagerAddress txnArgs.MethodName = "delegate" txnArgs.ABI = bindings.StakeManagerMetaData.ABI txnArgs.Parameters = []interface{}{stakerId, txnArgs.Amount} - delegationTxnOpts := razorUtils.GetTxnOpts(txnArgs) + delegationTxnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) + if err != nil { + return core.NilHash, err + } log.Info("Sending Delegate transaction...") + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debugf("Executing Delegate transaction with stakerId = %d, amount = %s", stakerId, txnArgs.Amount) - txn, err := stakeManagerUtils.Delegate(txnArgs.Client, delegationTxnOpts, stakerId, txnArgs.Amount) + txn, err := stakeManagerUtils.Delegate(client, delegationTxnOpts, stakerId, txnArgs.Amount) if err != nil { return core.NilHash, err } diff --git a/cmd/delegate_test.go b/cmd/delegate_test.go index fe6ac8811..b0771a178 100644 --- a/cmd/delegate_test.go +++ b/cmd/delegate_test.go @@ -20,6 +20,7 @@ func TestDelegate(t *testing.T) { type args struct { amount *big.Int + txnOptsErr error delegateTxn *Types.Transaction delegateErr error hash common.Hash @@ -52,18 +53,27 @@ func TestDelegate(t *testing.T) { want: core.NilHash, wantErr: errors.New("delegate error"), }, + { + name: "Test 3: When there is an error in getting txnOpts", + args: args{ + amount: big.NewInt(1000), + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) stakeManagerMock.On("Delegate", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.delegateTxn, tt.args.delegateErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.Delegate(types.TransactionOptions{ + got, err := utils.Delegate(rpcParameters, types.TransactionOptions{ Amount: tt.args.amount, }, stakerId) if got != tt.want { @@ -104,9 +114,9 @@ func TestExecuteDelegate(t *testing.T) { delegateErr error } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } tests := []struct { name string @@ -236,7 +246,9 @@ func TestExecuteDelegate(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("AssignPassword", flagSet).Return(tt.args.password) @@ -245,13 +257,13 @@ func TestExecuteDelegate(t *testing.T) { flagSetMock.On("GetStringAddress", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.address, tt.args.addressErr) flagSetMock.On("GetUint32StakerId", flagSet).Return(tt.args.stakerId, tt.args.stakerIdErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) - utilsMock.On("FetchBalance", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.balance, tt.args.balanceErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) + utilsMock.On("FetchBalance", mock.Anything, mock.Anything).Return(tt.args.balance, tt.args.balanceErr) cmdUtilsMock.On("AssignAmountInWei", flagSet).Return(tt.args.amount, tt.args.amountErr) utilsMock.On("CheckAmountAndBalance", mock.AnythingOfType("*big.Int"), mock.AnythingOfType("*big.Int")).Return(tt.args.amount) - utilsMock.On("CheckEthBalanceIsZero", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return() - cmdUtilsMock.On("Approve", mock.Anything).Return(tt.args.approveTxn, tt.args.approveErr) - cmdUtilsMock.On("Delegate", mock.Anything, mock.AnythingOfType("uint32")).Return(tt.args.delegateHash, tt.args.delegateErr) + utilsMock.On("CheckEthBalanceIsZero", mock.Anything, mock.Anything).Return() + cmdUtilsMock.On("Approve", mock.Anything, mock.Anything).Return(tt.args.approveTxn, tt.args.approveErr) + cmdUtilsMock.On("Delegate", mock.Anything, mock.Anything, mock.AnythingOfType("uint32")).Return(tt.args.delegateHash, tt.args.delegateErr) utils := &UtilsStruct{} fatal = false diff --git a/cmd/dispute.go b/cmd/dispute.go index 516cef698..9d9d6c939 100644 --- a/cmd/dispute.go +++ b/cmd/dispute.go @@ -9,6 +9,7 @@ import ( "razor/core/types" "razor/path" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "strings" @@ -16,7 +17,6 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" solsha3 "github.com/miguelmota/go-solidity-sha3" ) @@ -27,23 +27,23 @@ var ( //blockId is id of the block //This function handles the dispute and if there is any error it returns the error -func (*UtilsStruct) HandleDispute(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue, backupNodeActionsToIgnore []string) error { +func (*UtilsStruct) HandleDispute(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue, backupNodeActionsToIgnore []string) error { - sortedProposedBlockIds, err := razorUtils.GetSortedProposedBlockIds(client, epoch) + sortedProposedBlockIds, err := razorUtils.GetSortedProposedBlockIds(rpcParameters, epoch) if err != nil { log.Error("Error in fetching sorted proposed block id: ", err) return err } log.Debug("HandleDispute: SortedProposedBlockIds: ", sortedProposedBlockIds) - biggestStake, biggestStakerId, err := cmdUtils.GetBiggestStakeAndId(client, epoch) + biggestStake, biggestStakerId, err := cmdUtils.GetBiggestStakeAndId(rpcParameters, epoch) if err != nil { return err } log.Debugf("HandleDispute: Biggest stake: %s, Biggest staker Id: %d", biggestStake, biggestStakerId) log.Debugf("HandleDispute: Calling GetLocalMediansData() with arguments epoch = %d, blockNumber = %d, rogueData = %+v", epoch, blockNumber, rogueData) - locallyCalculatedData, err := cmdUtils.GetLocalMediansData(client, account, epoch, blockNumber, rogueData) + locallyCalculatedData, err := cmdUtils.GetLocalMediansData(rpcParameters, account, epoch, blockNumber, rogueData) if err != nil { return err } @@ -57,7 +57,6 @@ func (*UtilsStruct) HandleDispute(client *ethclient.Client, config types.Configu randomSortedProposedBlockIds := utils.Shuffle(sortedProposedBlockIds) //shuffles the sortedProposedBlockIds array transactionOptions := types.TransactionOptions{ - Client: client, ChainId: core.ChainId, Config: config, Account: account, @@ -66,7 +65,7 @@ func (*UtilsStruct) HandleDispute(client *ethclient.Client, config types.Configu log.Debug("Iterating over random sorted proposed blocks to check dispute...") for _, blockId := range randomSortedProposedBlockIds { - proposedBlock, err := razorUtils.GetProposedBlock(client, epoch, blockId) + proposedBlock, err := razorUtils.GetProposedBlock(rpcParameters, epoch, blockId) if err != nil { log.Error(err) continue @@ -86,12 +85,22 @@ func (*UtilsStruct) HandleDispute(client *ethclient.Client, config types.Configu log.Debug("Biggest Stake in proposed block: ", proposedBlock.BiggestStake) log.Warn("PROPOSED BIGGEST STAKE DOES NOT MATCH WITH ACTUAL BIGGEST STAKE") log.Info("Disputing BiggestStakeProposed...") - txnOpts := razorUtils.GetTxnOpts(types.TransactionOptions{ - Client: client, + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{ ChainId: core.ChainId, Config: config, Account: account, }) + if err != nil { + log.Error(err) + continue + } + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + log.Error(err) + continue + } + log.Debugf("Executing DisputeBiggestStakeProposed transaction with arguments epoch = %d, blockIndex = %d, biggest staker Id = %d", epoch, blockIndex, biggestStakerId) disputeBiggestStakeProposedTxn, err := blockManagerUtils.DisputeBiggestStakeProposed(client, txnOpts, epoch, uint8(blockIndex), biggestStakerId) if err != nil { @@ -100,12 +109,12 @@ func (*UtilsStruct) HandleDispute(client *ethclient.Client, config types.Configu } disputeBiggestStakeProposedTxnHash := transactionUtils.Hash(disputeBiggestStakeProposedTxn) log.Info("Txn Hash: ", disputeBiggestStakeProposedTxnHash.Hex()) - WaitForBlockCompletionErr := razorUtils.WaitForBlockCompletion(client, disputeBiggestStakeProposedTxnHash.Hex()) + WaitForBlockCompletionErr := razorUtils.WaitForBlockCompletion(rpcParameters, disputeBiggestStakeProposedTxnHash.Hex()) //If dispute happens, then storing the bountyId into disputeData file if WaitForBlockCompletionErr == nil { log.Debug("Storing bounty Id in dispute data file....") - err = cmdUtils.StoreBountyId(client, account) + err = cmdUtils.StoreBountyId(rpcParameters, account) if err != nil { log.Error(err) } @@ -118,7 +127,7 @@ func (*UtilsStruct) HandleDispute(client *ethclient.Client, config types.Configu log.Debug("HandleDispute: Revealed collection ids in the block ", proposedBlock.Ids) log.Debugf("HandleDispute: Calling CheckDisputeForIds() with arguments epoch = %d, blockIndex = %d, proposed revealed Ids = %v, locally calculated revealed Ids = %v", epoch, blockIndex, proposedBlock.Ids, revealedCollectionIds) - idDisputeTxn, err := cmdUtils.CheckDisputeForIds(client, transactionOptions, epoch, uint8(blockIndex), proposedBlock.Ids, revealedCollectionIds) + idDisputeTxn, err := cmdUtils.CheckDisputeForIds(rpcParameters, transactionOptions, epoch, uint8(blockIndex), proposedBlock.Ids, revealedCollectionIds) if err != nil { log.Error("Error in disputing: ", err) continue @@ -126,12 +135,12 @@ func (*UtilsStruct) HandleDispute(client *ethclient.Client, config types.Configu if idDisputeTxn != nil { idDisputeTxnHash := transactionUtils.Hash(idDisputeTxn) log.Debugf("Txn Hash: %s", idDisputeTxnHash.Hex()) - WaitForBlockCompletionErr := razorUtils.WaitForBlockCompletion(client, idDisputeTxnHash.Hex()) + WaitForBlockCompletionErr := razorUtils.WaitForBlockCompletion(rpcParameters, idDisputeTxnHash.Hex()) //If dispute happens, then storing the bountyId into disputeData file if WaitForBlockCompletionErr == nil { log.Debug("Storing bounty Id in dispute data file...") - err = cmdUtils.StoreBountyId(client, account) + err = cmdUtils.StoreBountyId(rpcParameters, account) if err != nil { log.Error(err) } @@ -164,14 +173,14 @@ func (*UtilsStruct) HandleDispute(client *ethclient.Client, config types.Configu sortedValues := revealedDataMaps.SortedRevealedValues[collectionIdOfWrongMedian-1] log.Debug("HandleDispute: Sorted values: ", sortedValues) - leafId, err := razorUtils.GetLeafIdOfACollection(client, collectionIdOfWrongMedian) + leafId, err := razorUtils.GetLeafIdOfACollection(rpcParameters, collectionIdOfWrongMedian) if err != nil { log.Error("Error in leaf id: ", err) continue } log.Debug("HandleDispute: Leaf Id: ", leafId) log.Debugf("Calling Dispute() with arguments epoch = %d, blockIndex = %d, proposed block = %+v, leafId = %d, sortedValues = %s", epoch, uint8(blockIndex), proposedBlock, leafId, sortedValues) - disputeErr := cmdUtils.Dispute(client, config, account, epoch, uint8(blockIndex), proposedBlock, leafId, sortedValues) + disputeErr := cmdUtils.Dispute(rpcParameters, config, account, epoch, uint8(blockIndex), proposedBlock, leafId, sortedValues) if disputeErr != nil { log.Error("Error in disputing...", disputeErr) continue @@ -191,11 +200,11 @@ func (*UtilsStruct) HandleDispute(client *ethclient.Client, config types.Configu } //This function returns the local median data -func (*UtilsStruct) GetLocalMediansData(client *ethclient.Client, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue) (types.ProposeFileData, error) { +func (*UtilsStruct) GetLocalMediansData(rpcParameters rpc.RPCParameters, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue) (types.ProposeFileData, error) { if rogueData.IsRogue { // As the staker has proposed with incorrect medians in rogue mode so those values needs to be compared with the correct calculated medians log.Debug("Staker proposed in rogue mode, now calculating medians correctly...") - return calculateMedian(client, account, epoch, blockNumber) + return calculateMedian(rpcParameters, account, epoch, blockNumber) } // Fetching the data from file only if the node is not in rogue mode and @@ -206,18 +215,18 @@ func (*UtilsStruct) GetLocalMediansData(client *ethclient.Client, account types. fileName, err := pathUtils.GetProposeDataFileName(account.Address) if err != nil { log.Error("Error in getting file name to read median data: ", err) - return calculateMedian(client, account, epoch, blockNumber) + return calculateMedian(rpcParameters, account, epoch, blockNumber) } log.Debug("GetLocalMediansData: Propose data file path: ", fileName) proposedData, err := fileUtils.ReadFromProposeJsonFile(fileName) if err != nil { log.Errorf("Error in getting propose data from file %s: %v", fileName, err) - return calculateMedian(client, account, epoch, blockNumber) + return calculateMedian(rpcParameters, account, epoch, blockNumber) } log.Debugf("GetLocalMediansData: Proposed data from file: %+v", proposedData) if proposedData.Epoch != epoch { log.Errorf("File %s doesn't contain latest median data", fileName) - return calculateMedian(client, account, epoch, blockNumber) + return calculateMedian(rpcParameters, account, epoch, blockNumber) } return proposedData, err } @@ -225,8 +234,8 @@ func (*UtilsStruct) GetLocalMediansData(client *ethclient.Client, account types. return globalProposedDataStruct, nil } -func calculateMedian(client *ethclient.Client, account types.Account, epoch uint32, blockNumber *big.Int) (types.ProposeFileData, error) { - stakerId, err := razorUtils.GetStakerId(client, account.Address) +func calculateMedian(rpcParameters rpc.RPCParameters, account types.Account, epoch uint32, blockNumber *big.Int) (types.ProposeFileData, error) { + stakerId, err := razorUtils.GetStakerId(rpcParameters, account.Address) if err != nil { log.Error("Error in getting stakerId: ", err) return types.ProposeFileData{}, err @@ -235,7 +244,7 @@ func calculateMedian(client *ethclient.Client, account types.Account, epoch uint log.Debug("Calculating the medians data again...") log.Debugf("GetLocalMediansData: Calling MakeBlock() with arguments blockNumber = %s, epoch = %d, rogueData = %+v", blockNumber, epoch, types.Rogue{IsRogue: false}) - medians, revealedCollectionIds, revealedDataMaps, err := cmdUtils.MakeBlock(client, blockNumber, epoch, types.Rogue{IsRogue: false}) + medians, revealedCollectionIds, revealedDataMaps, err := cmdUtils.MakeBlock(rpcParameters, blockNumber, epoch, types.Rogue{IsRogue: false}) if err != nil { log.Error("Error in calculating block medians: ", err) return types.ProposeFileData{}, err @@ -252,7 +261,7 @@ func calculateMedian(client *ethclient.Client, account types.Account, epoch uint } //This function check for the dispute in different type of Id's -func (*UtilsStruct) CheckDisputeForIds(client *ethclient.Client, transactionOpts types.TransactionOptions, epoch uint32, blockIndex uint8, idsInProposedBlock []uint16, revealedCollectionIds []uint16) (*Types.Transaction, error) { +func (*UtilsStruct) CheckDisputeForIds(rpcParameters rpc.RPCParameters, transactionOpts types.TransactionOptions, epoch uint32, blockIndex uint8, idsInProposedBlock []uint16, revealedCollectionIds []uint16) (*Types.Transaction, error) { //checking for hashing whether there is any dispute or not hashIdsInProposedBlock := solsha3.SoliditySHA3([]string{"uint16[]"}, []interface{}{idsInProposedBlock}) log.Debug("CheckDisputeForIds: Hash of reveal Ids in proposed block: ", hashIdsInProposedBlock) @@ -272,7 +281,16 @@ func (*UtilsStruct) CheckDisputeForIds(client *ethclient.Client, transactionOpts transactionOpts.ABI = bindings.BlockManagerMetaData.ABI transactionOpts.MethodName = "disputeOnOrderOfIds" transactionOpts.Parameters = []interface{}{epoch, blockIndex, index0, index1} - txnOpts := razorUtils.GetTxnOpts(transactionOpts) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, transactionOpts) + if err != nil { + return nil, err + } + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return nil, err + } + log.Debug("Disputing sorted order of ids!") log.Debugf("CheckDisputeForIds: Executing DisputeOnOrderOfIds transaction with arguments epoch: %d, blockIndex: %d, index0: %d, index1: %d", epoch, blockIndex, index0, index1) return blockManagerUtils.DisputeOnOrderOfIds(client, txnOpts, epoch, blockIndex, big.NewInt(int64(index0)), big.NewInt(int64(index1))) @@ -284,13 +302,22 @@ func (*UtilsStruct) CheckDisputeForIds(client *ethclient.Client, transactionOpts transactionOpts.ABI = bindings.BlockManagerMetaData.ABI transactionOpts.MethodName = "disputeCollectionIdShouldBePresent" transactionOpts.Parameters = []interface{}{epoch, blockIndex, missingCollectionId} - txnOpts := razorUtils.GetTxnOpts(transactionOpts) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, transactionOpts) + if err != nil { + return nil, err + } gasLimit := txnOpts.GasLimit - incrementedGasLimit, err := gasUtils.IncreaseGasLimitValue(client, gasLimit, core.DisputeGasMultiplier) + incrementedGasLimit, err := gasUtils.IncreaseGasLimitValue(rpcParameters, gasLimit, core.DisputeGasMultiplier) if err != nil { return nil, err } txnOpts.GasLimit = incrementedGasLimit + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return nil, err + } + log.Debug("Disputing collection id should be present!") log.Debugf("CheckDisputeForIds: Executing DisputeCollectionIdShouldBePresent transaction with arguments epoch: %d, blockIndex: %d, missingCollectionId: %d", epoch, blockIndex, missingCollectionId) return blockManagerUtils.DisputeCollectionIdShouldBePresent(client, txnOpts, epoch, blockIndex, missingCollectionId) @@ -302,13 +329,22 @@ func (*UtilsStruct) CheckDisputeForIds(client *ethclient.Client, transactionOpts transactionOpts.ABI = bindings.BlockManagerMetaData.ABI transactionOpts.MethodName = "disputeCollectionIdShouldBeAbsent" transactionOpts.Parameters = []interface{}{epoch, blockIndex, presentCollectionId, big.NewInt(int64(positionOfPresentValue))} - txnOpts := razorUtils.GetTxnOpts(transactionOpts) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, transactionOpts) + if err != nil { + return nil, err + } gasLimit := txnOpts.GasLimit - incrementedGasLimit, err := gasUtils.IncreaseGasLimitValue(client, gasLimit, core.DisputeGasMultiplier) + incrementedGasLimit, err := gasUtils.IncreaseGasLimitValue(rpcParameters, gasLimit, core.DisputeGasMultiplier) if err != nil { return nil, err } txnOpts.GasLimit = incrementedGasLimit + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return nil, err + } + log.Debug("Disputing collection id should be absent!") log.Debugf("CheckDisputeForIds: Executing DisputeCollectionIdShouldBeAbsent transaction with arguments epoch: %d, blockIndex: %d, presentCollectionId: %d, positionOfPresentValue: %d", epoch, blockIndex, presentCollectionId, positionOfPresentValue) return blockManagerUtils.DisputeCollectionIdShouldBeAbsent(client, txnOpts, epoch, blockIndex, presentCollectionId, big.NewInt(int64(positionOfPresentValue))) @@ -318,11 +354,8 @@ func (*UtilsStruct) CheckDisputeForIds(client *ethclient.Client, transactionOpts } //This function finalizes the dispute and return the error if there is any -func (*UtilsStruct) Dispute(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, blockIndex uint8, proposedBlock bindings.StructsBlock, leafId uint16, sortedValues []*big.Int) error { - blockManager := razorUtils.GetBlockManager(client) - +func (*UtilsStruct) Dispute(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, blockIndex uint8, proposedBlock bindings.StructsBlock, leafId uint16, sortedValues []*big.Int) error { txnArgs := types.TransactionOptions{ - Client: client, ChainId: core.ChainId, Config: config, Account: account, @@ -342,15 +375,18 @@ func (*UtilsStruct) Dispute(client *ethclient.Client, config types.Configuration end = lenOfSortedValues } log.Debugf("Dispute: Calling GiveSorted with arguments epoch = %d, leafId = %d, sortedValues = %s", epoch, leafId, sortedValues[start:end]) - err := cmdUtils.GiveSorted(client, blockManager, txnArgs, epoch, leafId, sortedValues[start:end]) + err := cmdUtils.GiveSorted(rpcParameters, txnArgs, epoch, leafId, sortedValues[start:end]) if err != nil { if err.Error() == errors.New("gas limit reached").Error() { end = end / 2 } else { log.Error("Error in GiveSorted: ", err) - txnOpts := razorUtils.GetTxnOpts(txnArgs) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) + if err != nil { + return err + } log.Debugf("Dispute: Calling CheckToDoResetDispute with arguments epoch = %d, sortedValues = %s", epoch, sortedValues) - cmdUtils.CheckToDoResetDispute(client, blockManager, txnOpts, epoch, sortedValues) + cmdUtils.CheckToDoResetDispute(rpcParameters, txnOpts, epoch, sortedValues) return err } } else { @@ -368,7 +404,7 @@ func (*UtilsStruct) Dispute(client *ethclient.Client, config types.Configuration giveSortedLeafIds = append(giveSortedLeafIds, int(leafId)) } log.Debugf("Dispute: Calling GetCollectionIdPositionInBlock with arguments leafId = %d, proposed block = %+v", leafId, proposedBlock) - positionOfCollectionInBlock := cmdUtils.GetCollectionIdPositionInBlock(client, leafId, proposedBlock) + positionOfCollectionInBlock := cmdUtils.GetCollectionIdPositionInBlock(rpcParameters, leafId, proposedBlock) log.Debug("Dispute: Position of collection id in block: ", positionOfCollectionInBlock) log.Info("Finalizing dispute...") @@ -377,7 +413,15 @@ func (*UtilsStruct) Dispute(client *ethclient.Client, config types.Configuration finalizeDisputeTxnArgs.MethodName = "finalizeDispute" finalizeDisputeTxnArgs.ABI = bindings.BlockManagerMetaData.ABI finalizeDisputeTxnArgs.Parameters = []interface{}{epoch, blockIndex, positionOfCollectionInBlock} - finalizeDisputeTxnOpts := razorUtils.GetTxnOpts(finalizeDisputeTxnArgs) + finalizeDisputeTxnOpts, err := razorUtils.GetTxnOpts(rpcParameters, finalizeDisputeTxnArgs) + if err != nil { + return err + } + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return err + } log.Debugf("Executing FinalizeDispute transaction with arguments epoch = %d, blockIndex = %d, positionOfCollectionInBlock = %d", epoch, blockIndex, positionOfCollectionInBlock) finalizeTxn, err := blockManagerUtils.FinalizeDispute(client, finalizeDisputeTxnOpts, epoch, blockIndex, positionOfCollectionInBlock) @@ -391,11 +435,11 @@ func (*UtilsStruct) Dispute(client *ethclient.Client, config types.Configuration finalizeTxnHash := transactionUtils.Hash(finalizeTxn) log.Info("Txn Hash: ", finalizeTxnHash.Hex()) log.Debug("Dispute: Checking mining status of FinalizeDispute transaction...") - WaitForBlockCompletionErr := razorUtils.WaitForBlockCompletion(client, finalizeTxnHash.Hex()) + WaitForBlockCompletionErr := razorUtils.WaitForBlockCompletion(rpcParameters, finalizeTxnHash.Hex()) //If dispute happens, then storing the bountyId into disputeData file if WaitForBlockCompletionErr == nil { log.Debug("Storing bounty Id in dispute data file...") - err = cmdUtils.StoreBountyId(client, account) + err = cmdUtils.StoreBountyId(rpcParameters, account) if err != nil { return err } @@ -412,23 +456,29 @@ func (*UtilsStruct) Dispute(client *ethclient.Client, config types.Configuration resetDisputeTxnArgs.MethodName = "resetDispute" resetDisputeTxnArgs.ABI = bindings.BlockManagerMetaData.ABI resetDisputeTxnArgs.Parameters = []interface{}{epoch} - resetDisputeTxnOpts := razorUtils.GetTxnOpts(resetDisputeTxnArgs) + resetDisputeTxnOpts, err := razorUtils.GetTxnOpts(rpcParameters, resetDisputeTxnArgs) + if err != nil { + return err + } - cmdUtils.ResetDispute(client, blockManager, resetDisputeTxnOpts, epoch) + cmdUtils.ResetDispute(rpcParameters, resetDisputeTxnOpts, epoch) return nil } //This function sorts the Id's recursively -func GiveSorted(client *ethclient.Client, blockManager *bindings.BlockManager, txnArgs types.TransactionOptions, epoch uint32, leafId uint16, sortedValues []*big.Int) error { +func GiveSorted(rpcParameters rpc.RPCParameters, txnArgs types.TransactionOptions, epoch uint32, leafId uint16, sortedValues []*big.Int) error { if len(sortedValues) == 0 { return errors.New("length of sortedValues is 0") } - callOpts := razorUtils.GetOptions() - txnOpts := razorUtils.GetTxnOpts(txnArgs) - disputesMapping, err := blockManagerUtils.Disputes(client, &callOpts, epoch, common.HexToAddress(txnArgs.Account.Address)) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) if err != nil { - log.Error("Error in getting disputes mapping: ", disputesMapping) + log.Error("Error in getting txnOpts: ", err) + return err + } + disputesMapping, err := razorUtils.Disputes(rpcParameters, epoch, common.HexToAddress(txnArgs.Account.Address)) + if err != nil { + log.Error("Error in getting disputes mapping: ", err) return err } log.Debugf("GiveSorted: Disputes mapping: %+v", disputesMapping) @@ -445,8 +495,14 @@ func GiveSorted(client *ethclient.Client, blockManager *bindings.BlockManager, t log.Debug("GiveSorted: Is give sorted initiated: ", isGiveSortedInitiated) log.Info("Calling GiveSorted...") + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return err + } + log.Debugf("Executing GiveSorted transaction with arguments epoch = %d, leafId = %d , sortedValues = %s", epoch, leafId, sortedValues) - txn, err := blockManagerUtils.GiveSorted(blockManager, txnOpts, epoch, leafId, sortedValues) + txn, err := blockManagerUtils.GiveSorted(client, txnOpts, epoch, leafId, sortedValues) if err != nil { return err } @@ -454,7 +510,7 @@ func GiveSorted(client *ethclient.Client, blockManager *bindings.BlockManager, t txnHash := transactionUtils.Hash(txn) log.Info("Txn Hash: ", txnHash.Hex()) giveSortedLeafIds = append(giveSortedLeafIds, int(leafId)) - err = razorUtils.WaitForBlockCompletion(client, txnHash.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txnHash.Hex()) if err != nil { log.Error("Error in WaitForBlockCompletion for giveSorted: ", err) return err @@ -463,9 +519,9 @@ func GiveSorted(client *ethclient.Client, blockManager *bindings.BlockManager, t } //This function returns the collection Id position in block -func (*UtilsStruct) GetCollectionIdPositionInBlock(client *ethclient.Client, leafId uint16, proposedBlock bindings.StructsBlock) *big.Int { +func (*UtilsStruct) GetCollectionIdPositionInBlock(rpcParameters rpc.RPCParameters, leafId uint16, proposedBlock bindings.StructsBlock) *big.Int { ids := proposedBlock.Ids - idToBeDisputed, err := razorUtils.GetCollectionIdFromLeafId(client, leafId) + idToBeDisputed, err := razorUtils.GetCollectionIdFromLeafId(rpcParameters, leafId) if err != nil { log.Error("Error in fetching collection id from leaf id") return nil @@ -481,7 +537,7 @@ func (*UtilsStruct) GetCollectionIdPositionInBlock(client *ethclient.Client, lea } //This function saves the bountyId in disputeData file and return the error if there is any -func (*UtilsStruct) StoreBountyId(client *ethclient.Client, account types.Account) error { +func (*UtilsStruct) StoreBountyId(rpcParameters rpc.RPCParameters, account types.Account) error { disputeFilePath, err := pathUtils.GetDisputeDataFileName(account.Address) if err != nil { return err @@ -490,7 +546,7 @@ func (*UtilsStruct) StoreBountyId(client *ethclient.Client, account types.Accoun var latestBountyId uint32 - latestHeader, err := clientUtils.GetLatestBlockWithRetry(client) + latestHeader, err := clientUtils.GetLatestBlockWithRetry(rpcParameters) if err != nil { log.Error("Error in fetching block: ", err) return err @@ -498,7 +554,7 @@ func (*UtilsStruct) StoreBountyId(client *ethclient.Client, account types.Accoun log.Debug("StoreBountyId: Latest header: ", latestHeader) log.Debugf("StoreBountyId: Calling GetBountyIdFromEvents with arguments blockNumber = %d, address = %s", latestHeader.Number, account.Address) - latestBountyId, err = cmdUtils.GetBountyIdFromEvents(client, latestHeader.Number, account.Address) + latestBountyId, err = cmdUtils.GetBountyIdFromEvents(rpcParameters, latestHeader.Number, account.Address) if err != nil { return err } @@ -527,16 +583,20 @@ func (*UtilsStruct) StoreBountyId(client *ethclient.Client, account types.Accoun } //This function resets the dispute -func (*UtilsStruct) ResetDispute(client *ethclient.Client, blockManager *bindings.BlockManager, txnOpts *bind.TransactOpts, epoch uint32) { +func (*UtilsStruct) ResetDispute(rpcParameters rpc.RPCParameters, txnOpts *bind.TransactOpts, epoch uint32) { + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return + } log.Debug("Executing ResetDispute transaction with arguments epoch = ", epoch) - txn, err := blockManagerUtils.ResetDispute(blockManager, txnOpts, epoch) + txn, err := blockManagerUtils.ResetDispute(client, txnOpts, epoch) if err != nil { log.Error("error in resetting dispute", err) return } txnHash := transactionUtils.Hash(txn) log.Info("Txn Hash: ", txnHash.Hex()) - err = razorUtils.WaitForBlockCompletion(client, txnHash.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txnHash.Hex()) if err != nil { log.Error("Error in WaitForBlockCompletion for resetDispute: ", err) return @@ -545,8 +605,8 @@ func (*UtilsStruct) ResetDispute(client *ethclient.Client, blockManager *binding } //This function returns the bountyId from events -func (*UtilsStruct) GetBountyIdFromEvents(client *ethclient.Client, blockNumber *big.Int, bountyHunter string) (uint32, error) { - fromBlock, err := razorUtils.EstimateBlockNumberAtEpochBeginning(client, blockNumber) +func (*UtilsStruct) GetBountyIdFromEvents(rpcParameters rpc.RPCParameters, blockNumber *big.Int, bountyHunter string) (uint32, error) { + fromBlock, err := razorUtils.EstimateBlockNumberAtEpochBeginning(rpcParameters, blockNumber) if err != nil { log.Error(err) return 0, err @@ -560,7 +620,7 @@ func (*UtilsStruct) GetBountyIdFromEvents(client *ethclient.Client, blockNumber }, } log.Debugf("GetBountyIdFromEvents: Query to send in filter logs: %+v", query) - logs, err := clientUtils.FilterLogsWithRetry(client, query) + logs, err := clientUtils.FilterLogsWithRetry(rpcParameters, query) if err != nil { return 0, err } @@ -588,10 +648,9 @@ func (*UtilsStruct) GetBountyIdFromEvents(client *ethclient.Client, blockNumber return bountyId, nil } -func (*UtilsStruct) CheckToDoResetDispute(client *ethclient.Client, blockManager *bindings.BlockManager, txnOpts *bind.TransactOpts, epoch uint32, sortedValues []*big.Int) { +func (*UtilsStruct) CheckToDoResetDispute(rpcParameters rpc.RPCParameters, txnOpts *bind.TransactOpts, epoch uint32, sortedValues []*big.Int) { // Fetch updated dispute mapping - callOpts := razorUtils.GetOptions() - disputesMapping, err := blockManagerUtils.Disputes(client, &callOpts, epoch, txnOpts.From) + disputesMapping, err := razorUtils.Disputes(rpcParameters, epoch, txnOpts.From) if err != nil { log.Error("Error in getting disputes mapping: ", disputesMapping) return @@ -601,6 +660,6 @@ func (*UtilsStruct) CheckToDoResetDispute(client *ethclient.Client, blockManager //Checking whether LVV is equal to maximum value in sortedValues, if not equal resetting dispute if disputesMapping.LastVisitedValue.Cmp(big.NewInt(0)) != 0 && disputesMapping.LastVisitedValue.Cmp(sortedValues[len(sortedValues)-1]) != 0 { log.Debug("CheckToDoResetDispute: Calling Reset Dispute with arguments epoch = ", epoch) - cmdUtils.ResetDispute(client, blockManager, txnOpts, epoch) + cmdUtils.ResetDispute(rpcParameters, txnOpts, epoch) } } diff --git a/cmd/dispute_test.go b/cmd/dispute_test.go index 2a473f238..b66c5c920 100644 --- a/cmd/dispute_test.go +++ b/cmd/dispute_test.go @@ -5,7 +5,6 @@ import ( "crypto/rand" "errors" "fmt" - "github.com/ethereum/go-ethereum/crypto" "io/fs" "math/big" "razor/core/types" @@ -13,17 +12,17 @@ import ( "reflect" "testing" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/mock" ) func TestDispute(t *testing.T) { var ( - client *ethclient.Client config types.Configurations account types.Account epoch uint32 @@ -93,19 +92,19 @@ func TestDispute(t *testing.T) { SetUpMockInterfaces() utilsMock.On("GetBlockManager", mock.AnythingOfType("*ethclient.Client")).Return(blockManager) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetTxnOpts", mock.Anything, mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts, nil) cmdUtilsMock.On("GiveSorted", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) cmdUtilsMock.On("GetCollectionIdPositionInBlock", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.positionOfCollectionInBlock) blockManagerMock.On("FinalizeDispute", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.finalizeDisputeTxn, tt.args.finalizeDisputeErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) cmdUtilsMock.On("StoreBountyId", mock.Anything, mock.Anything).Return(tt.args.storeBountyIdErr) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) cmdUtilsMock.On("CheckToDoResetDispute", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return() - cmdUtilsMock.On("ResetDispute", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything) + cmdUtilsMock.On("ResetDispute", mock.Anything, mock.Anything, mock.Anything) utils := &UtilsStruct{} - err := utils.Dispute(client, config, account, epoch, blockIndex, proposedBlock, leafId, tt.args.sortedValues) + err := utils.Dispute(rpcParameters, config, account, epoch, blockIndex, proposedBlock, leafId, tt.args.sortedValues) if err == nil || tt.want == nil { if err != tt.want { t.Errorf("Error for Dispute function, got = %v, want = %v", err, tt.want) @@ -123,7 +122,6 @@ func TestHandleDispute(t *testing.T) { privateKey, _ := ecdsa.GenerateKey(crypto.S256(), rand.Reader) txnOpts, _ := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(31337)) - var client *ethclient.Client var config types.Configurations var account types.Account var epoch uint32 @@ -524,27 +522,27 @@ func TestHandleDispute(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetSortedProposedBlockIds", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.sortedProposedBlockIds, tt.args.sortedProposedBlockIdsErr) - cmdUtilsMock.On("GetBiggestStakeAndId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.biggestStake, tt.args.biggestStakeId, tt.args.biggestStakeErr) - cmdUtilsMock.On("GetLocalMediansData", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(types.ProposeFileData{ + utilsMock.On("GetSortedProposedBlockIds", mock.Anything, mock.Anything).Return(tt.args.sortedProposedBlockIds, tt.args.sortedProposedBlockIdsErr) + cmdUtilsMock.On("GetBiggestStakeAndId", mock.Anything, mock.Anything).Return(tt.args.biggestStake, tt.args.biggestStakeId, tt.args.biggestStakeErr) + cmdUtilsMock.On("GetLocalMediansData", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(types.ProposeFileData{ MediansData: tt.args.medians, RevealedCollectionIds: tt.args.revealedCollectionIds, RevealedDataMaps: tt.args.revealedDataMaps, }, tt.args.mediansErr) - utilsMock.On("GetProposedBlock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(tt.args.proposedBlock, tt.args.proposedBlockErr) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(txnOpts) + utilsMock.On("GetProposedBlock", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.proposedBlock, tt.args.proposedBlockErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(txnOpts, nil) blockManagerMock.On("DisputeBiggestStakeProposed", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.disputeBiggestStakeTxn, tt.args.disputeBiggestStakeErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.Hash) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) - cmdUtilsMock.On("CheckDisputeForIds", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.idDisputeTxn, tt.args.idDisputeTxnErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) + cmdUtilsMock.On("CheckDisputeForIds", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.idDisputeTxn, tt.args.idDisputeTxnErr) utilsMock.On("GetLeafIdOfACollection", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.leafId, tt.args.leafIdErr) cmdUtilsMock.On("Dispute", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.disputeErr) utilsMock.On("GetBlockManager", mock.AnythingOfType("*ethclient.Client")).Return(blockManager) cmdUtilsMock.On("StoreBountyId", mock.Anything, mock.Anything).Return(tt.args.storeBountyIdErr) - cmdUtilsMock.On("ResetDispute", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything) + cmdUtilsMock.On("ResetDispute", mock.Anything, mock.Anything, mock.Anything) utils := &UtilsStruct{} - err := utils.HandleDispute(client, config, account, epoch, blockNumber, rogueData, backupNodeActionsToIgnore) + err := utils.HandleDispute(rpcParameters, config, account, epoch, blockNumber, rogueData, backupNodeActionsToIgnore) if err == nil || tt.want == nil { if err != tt.want { t.Errorf("Error for HandleDispute function, got = %v, want = %v", err, tt.want) @@ -568,8 +566,6 @@ func TestGiveSorted(t *testing.T) { AccWeight: big.NewInt(0), } - var client *ethclient.Client - var blockManager *bindings.BlockManager var txnArgs types.TransactionOptions var epoch uint32 var callOpts bind.CallOpts @@ -657,16 +653,16 @@ func TestGiveSorted(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - blockManagerMock.On("GiveSorted", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.giveSorted, tt.args.giveSortedErr).Once() + blockManagerMock.On("GiveSorted", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.giveSorted, tt.args.giveSortedErr).Once() transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.waitForBlockCompletionErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(tt.args.waitForBlockCompletionErr) utilsMock.On("GetOptions").Return(callOpts) - blockManagerMock.On("Disputes", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.disputesMapping, tt.args.disputesMappingErr) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(txnOpts) - blockManagerMock.On("GiveSorted", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.giveSorted, nil) - cmdUtilsMock.On("ResetDispute", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything) + utilsMock.On("Disputes", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.disputesMapping, tt.args.disputesMappingErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.AnythingOfType("types.TransactionOptions")).Return(txnOpts, nil) + blockManagerMock.On("GiveSorted", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.giveSorted, nil) + cmdUtilsMock.On("ResetDispute", mock.Anything, mock.Anything, mock.Anything) - err := GiveSorted(client, blockManager, txnArgs, epoch, tt.args.leafId, tt.args.sortedValues) + err := GiveSorted(rpcParameters, txnArgs, epoch, tt.args.leafId, tt.args.sortedValues) if (err != nil) != tt.wantErr { t.Errorf("CheckDisputeForIds() error = %v, wantErr %v", err, tt.wantErr) return @@ -677,7 +673,6 @@ func TestGiveSorted(t *testing.T) { func TestGetLocalMediansData(t *testing.T) { var ( - client *ethclient.Client account types.Account blockNumber *big.Int ) @@ -794,10 +789,10 @@ func TestGetLocalMediansData(t *testing.T) { pathMock.On("GetProposeDataFileName", mock.AnythingOfType("string")).Return(tt.args.fileName, tt.args.fileNameErr) fileUtilsMock.On("ReadFromProposeJsonFile", mock.Anything).Return(tt.args.proposedData, tt.args.proposeDataErr) - cmdUtilsMock.On("MakeBlock", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything).Return(tt.args.medians, tt.args.revealedCollectionIds, tt.args.revealedDataMaps, tt.args.mediansErr) - utilsMock.On("GetStakerId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.stakerId, tt.args.stakerIdErr) + cmdUtilsMock.On("MakeBlock", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.medians, tt.args.revealedCollectionIds, tt.args.revealedDataMaps, tt.args.mediansErr) + utilsMock.On("GetStakerId", mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) ut := &UtilsStruct{} - localProposedData, err := ut.GetLocalMediansData(client, account, tt.args.epoch, blockNumber, types.Rogue{IsRogue: tt.args.isRogue}) + localProposedData, err := ut.GetLocalMediansData(rpcParameters, account, tt.args.epoch, blockNumber, types.Rogue{IsRogue: tt.args.isRogue}) if (err != nil) != tt.wantErr { t.Errorf("GetLocalMediansData() error = %v, wantErr %v", err, tt.wantErr) return @@ -816,7 +811,6 @@ func TestGetLocalMediansData(t *testing.T) { } func TestGetCollectionIdPositionInBlock(t *testing.T) { - var client *ethclient.Client var leafId uint16 type args struct { proposedBlock bindings.StructsBlock @@ -863,9 +857,9 @@ func TestGetCollectionIdPositionInBlock(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetCollectionIdFromLeafId", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.idToBeDisputed, tt.args.idToBeDisputedErr) + utilsMock.On("GetCollectionIdFromLeafId", mock.Anything, mock.Anything).Return(tt.args.idToBeDisputed, tt.args.idToBeDisputedErr) ut := &UtilsStruct{} - if got := ut.GetCollectionIdPositionInBlock(client, leafId, tt.args.proposedBlock); !reflect.DeepEqual(got, tt.want) { + if got := ut.GetCollectionIdPositionInBlock(rpcParameters, leafId, tt.args.proposedBlock); !reflect.DeepEqual(got, tt.want) { t.Errorf("GetCollectionIdPositionInBlock() = %v, want %v", got, tt.want) } }) @@ -874,7 +868,6 @@ func TestGetCollectionIdPositionInBlock(t *testing.T) { func TestCheckDisputeForIds(t *testing.T) { var ( - client *ethclient.Client transactionOpts types.TransactionOptions epoch uint32 blockIndex uint8 @@ -966,14 +959,14 @@ func TestCheckDisputeForIds(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(txnOpts) + utilsMock.On("GetTxnOpts", mock.Anything, mock.AnythingOfType("types.TransactionOptions")).Return(txnOpts, nil) blockManagerMock.On("DisputeOnOrderOfIds", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.DisputeOnOrderOfIds, tt.args.DisputeOnOrderOfIdsErr) gasUtilsMock.On("IncreaseGasLimitValue", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.incrementedGasLimit, tt.args.incrementedGasLimitErr) blockManagerMock.On("DisputeCollectionIdShouldBePresent", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.DisputeCollectionIdShouldBePresent, tt.args.DisputeCollectionIdShouldBePresentErr) blockManagerMock.On("DisputeCollectionIdShouldBeAbsent", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.DisputeCollectionIdShouldBeAbsent, tt.args.DisputeCollectionIdShouldBeAbsentErr) gasUtilsMock.On("IncreaseGasLimitValue", mock.Anything, mock.Anything, mock.Anything).Return(uint64(2000), nil) ut := &UtilsStruct{} - got, err := ut.CheckDisputeForIds(client, transactionOpts, epoch, blockIndex, tt.args.idsInProposedBlock, tt.args.revealedCollectionIds) + got, err := ut.CheckDisputeForIds(rpcParameters, transactionOpts, epoch, blockIndex, tt.args.idsInProposedBlock, tt.args.revealedCollectionIds) if (err != nil) != tt.wantErr { t.Errorf("CheckDisputeForIds() error = %v, wantErr %v", err, tt.wantErr) return @@ -987,7 +980,6 @@ func TestCheckDisputeForIds(t *testing.T) { func TestGetBountyIdFromEvents(t *testing.T) { var ( - client *ethclient.Client blockNumber *big.Int bountyHunter string ) @@ -1074,12 +1066,12 @@ func TestGetBountyIdFromEvents(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("EstimateBlockNumberAtEpochBeginning", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.fromBlock, tt.args.fromBlockErr) + utilsMock.On("EstimateBlockNumberAtEpochBeginning", mock.Anything, mock.Anything).Return(tt.args.fromBlock, tt.args.fromBlockErr) abiUtilsMock.On("Parse", mock.Anything).Return(tt.args.contractABI, tt.args.contractABIErr) - clientUtilsMock.On("FilterLogsWithRetry", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("ethereum.FilterQuery")).Return(tt.args.logs, tt.args.logsErr) + clientUtilsMock.On("FilterLogsWithRetry", mock.Anything, mock.Anything).Return(tt.args.logs, tt.args.logsErr) abiMock.On("Unpack", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.data, tt.args.unpackErr) ut := &UtilsStruct{} - got, err := ut.GetBountyIdFromEvents(client, blockNumber, bountyHunter) + got, err := ut.GetBountyIdFromEvents(rpcParameters, blockNumber, bountyHunter) if (err != nil) != tt.wantErr { t.Errorf("GetBountyIdFromEvents() error = %v, wantErr %v", err, tt.wantErr) return @@ -1093,10 +1085,8 @@ func TestGetBountyIdFromEvents(t *testing.T) { func TestResetDispute(t *testing.T) { var ( - client *ethclient.Client - blockManager *bindings.BlockManager - txnOpts *bind.TransactOpts - epoch uint32 + txnOpts *bind.TransactOpts + epoch uint32 ) type args struct { ResetDisputeTxn *Types.Transaction @@ -1127,16 +1117,15 @@ func TestResetDispute(t *testing.T) { blockManagerMock.On("ResetDispute", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.ResetDisputeTxn, tt.args.ResetDisputeTxnErr) transactionMock.On("Hash", mock.AnythingOfType("*types.Transaction")).Return(tt.args.hash) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) ut := &UtilsStruct{} - ut.ResetDispute(client, blockManager, txnOpts, epoch) + ut.ResetDispute(rpcParameters, txnOpts, epoch) }) } } func BenchmarkGetCollectionIdPositionInBlock(b *testing.B) { - var client *ethclient.Client var leafId uint16 var table = []struct { numOfIds uint16 @@ -1152,9 +1141,9 @@ func BenchmarkGetCollectionIdPositionInBlock(b *testing.B) { for i := 0; i < b.N; i++ { SetUpMockInterfaces() - utilsMock.On("GetCollectionIdFromLeafId", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(v.idToBeDisputed, nil) + utilsMock.On("GetCollectionIdFromLeafId", mock.Anything, mock.Anything, mock.Anything).Return(v.idToBeDisputed, nil) ut := &UtilsStruct{} - ut.GetCollectionIdPositionInBlock(client, leafId, bindings.StructsBlock{Ids: getDummyIds(v.numOfIds)}) + ut.GetCollectionIdPositionInBlock(rpcParameters, leafId, bindings.StructsBlock{Ids: getDummyIds(v.numOfIds)}) } }) } @@ -1164,7 +1153,6 @@ func BenchmarkHandleDispute(b *testing.B) { privateKey, _ := ecdsa.GenerateKey(crypto.S256(), rand.Reader) txnOpts, _ := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(31337)) - var client *ethclient.Client var config types.Configurations var account types.Account var epoch uint32 @@ -1202,22 +1190,22 @@ func BenchmarkHandleDispute(b *testing.B) { Valid: true, BiggestStake: big.NewInt(1).Mul(big.NewInt(5356), big.NewInt(1e18))} - utilsMock.On("GetSortedProposedBlockIds", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(getUint32DummyIds(v.numOfSortedBlocks), nil) - cmdUtilsMock.On("GetBiggestStakeAndId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(big.NewInt(1).Mul(big.NewInt(5356), big.NewInt(1e18)), uint32(2), nil) - cmdUtilsMock.On("GetLocalMediansData", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(proposedData, nil) - utilsMock.On("GetProposedBlock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(proposedBlock, nil) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(txnOpts) + utilsMock.On("GetSortedProposedBlockIds", mock.Anything, mock.Anything).Return(getUint32DummyIds(v.numOfSortedBlocks), nil) + cmdUtilsMock.On("GetBiggestStakeAndId", mock.Anything, mock.Anything).Return(big.NewInt(1).Mul(big.NewInt(5356), big.NewInt(1e18)), uint32(2), nil) + cmdUtilsMock.On("GetLocalMediansData", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(proposedData, nil) + utilsMock.On("GetProposedBlock", mock.Anything, mock.Anything, mock.Anything).Return(proposedBlock, nil) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(txnOpts, nil) blockManagerMock.On("DisputeBiggestStakeProposed", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(&Types.Transaction{}, nil) transactionMock.On("Hash", mock.Anything).Return(common.BigToHash(big.NewInt(1))) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) - cmdUtilsMock.On("CheckDisputeForIds", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(&Types.Transaction{}, nil) - utilsMock.On("GetLeafIdOfACollection", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(0, nil) - cmdUtilsMock.On("Dispute", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) + cmdUtilsMock.On("CheckDisputeForIds", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(&Types.Transaction{}, nil) + utilsMock.On("GetLeafIdOfACollection", mock.Anything, mock.Anything).Return(0, nil) + cmdUtilsMock.On("Dispute", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) utilsMock.On("GetBlockManager", mock.AnythingOfType("*ethclient.Client")).Return(blockManager) cmdUtilsMock.On("StoreBountyId", mock.Anything, mock.Anything).Return(nil) utils := &UtilsStruct{} - err := utils.HandleDispute(client, config, account, epoch, blockNumber, rogueData, backupNodeActionsToIgnore) + err := utils.HandleDispute(rpcParameters, config, account, epoch, blockNumber, rogueData, backupNodeActionsToIgnore) if err != nil { log.Fatal(err) } @@ -1229,7 +1217,6 @@ func BenchmarkHandleDispute(b *testing.B) { func TestStoreBountyId(t *testing.T) { var ( - client *ethclient.Client account types.Account fileInfo fs.FileInfo ) @@ -1334,14 +1321,14 @@ func TestStoreBountyId(t *testing.T) { SetUpMockInterfaces() pathMock.On("GetDisputeDataFileName", mock.AnythingOfType("string")).Return(tt.args.disputeFilePath, tt.args.disputeFilePathErr) - clientUtilsMock.On("GetLatestBlockWithRetry", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.latestHeader, tt.args.latestHeaderErr) - cmdUtilsMock.On("GetBountyIdFromEvents", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.latestBountyId, tt.args.latestBountyIdErr) + clientUtilsMock.On("GetLatestBlockWithRetry", mock.Anything).Return(tt.args.latestHeader, tt.args.latestHeaderErr) + cmdUtilsMock.On("GetBountyIdFromEvents", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.latestBountyId, tt.args.latestBountyIdErr) osPathMock.On("Stat", mock.Anything).Return(fileInfo, tt.args.statErr) fileUtilsMock.On("ReadFromDisputeJsonFile", mock.Anything).Return(tt.args.disputeData, tt.args.disputeDataErr) fileUtilsMock.On("SaveDataToDisputeJsonFile", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.saveDataErr) ut := &UtilsStruct{} - if err := ut.StoreBountyId(client, account); (err != nil) != tt.wantErr { + if err := ut.StoreBountyId(rpcParameters, account); (err != nil) != tt.wantErr { t.Errorf("AutoClaimBounty() error = %v, wantErr %v", err, tt.wantErr) } }) diff --git a/cmd/eventListeners.go b/cmd/eventListeners.go index 7b8d876fa..0c76c07d7 100644 --- a/cmd/eventListeners.go +++ b/cmd/eventListeners.go @@ -5,18 +5,18 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" "math/big" "razor/cache" "razor/core" "razor/core/types" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "strings" ) -func (*UtilsStruct) InitJobAndCollectionCache(client *ethclient.Client) (*cache.JobsCache, *cache.CollectionsCache, *big.Int, error) { - initAssetCacheBlock, err := clientUtils.GetLatestBlockWithRetry(client) +func (*UtilsStruct) InitJobAndCollectionCache(rpcParameters rpc.RPCParameters) (*cache.JobsCache, *cache.CollectionsCache, *big.Int, error) { + initAssetCacheBlock, err := clientUtils.GetLatestBlockWithRetry(rpcParameters) if err != nil { log.Error("Error in fetching block: ", err) return nil, nil, nil, err @@ -30,11 +30,11 @@ func (*UtilsStruct) InitJobAndCollectionCache(client *ethclient.Client) (*cache. collectionsCache := cache.NewCollectionsCache() // Initialize caches - if err := utils.InitJobsCache(client, jobsCache); err != nil { + if err := utils.InitJobsCache(rpcParameters, jobsCache); err != nil { log.Error("Error in initializing jobs cache: ", err) return nil, nil, nil, err } - if err := utils.InitCollectionsCache(client, collectionsCache); err != nil { + if err := utils.InitCollectionsCache(rpcParameters, collectionsCache); err != nil { log.Error("Error in initializing collections cache: ", err) return nil, nil, nil, err } @@ -43,7 +43,7 @@ func (*UtilsStruct) InitJobAndCollectionCache(client *ethclient.Client) (*cache. } // CheckForJobAndCollectionEvents checks for specific job and collections event that were emitted. -func CheckForJobAndCollectionEvents(client *ethclient.Client, commitParams *types.CommitParams) error { +func CheckForJobAndCollectionEvents(rpcParameters rpc.RPCParameters, commitParams *types.CommitParams) error { collectionManagerContractABI, err := abi.JSON(strings.NewReader(bindings.CollectionManagerMetaData.ABI)) if err != nil { log.Errorf("Error in parsing collection manager contract ABI: %v", err) @@ -53,14 +53,14 @@ func CheckForJobAndCollectionEvents(client *ethclient.Client, commitParams *type eventNames := []string{core.JobUpdatedEvent, core.CollectionUpdatedEvent, core.CollectionActivityStatusEvent, core.JobCreatedEvent, core.CollectionCreatedEvent} log.Debug("Checking for Job/Collection update events...") - toBlock, err := clientUtils.GetLatestBlockWithRetry(client) + toBlock, err := clientUtils.GetLatestBlockWithRetry(rpcParameters) if err != nil { log.Error("Error in getting latest block to start event listener: ", err) return err } // Process events and update the fromBlock for the next iteration - newFromBlock, err := processEvents(client, collectionManagerContractABI, commitParams.FromBlockToCheckForEvents, toBlock.Number, eventNames, commitParams.JobsCache, commitParams.CollectionsCache) + newFromBlock, err := processEvents(rpcParameters, collectionManagerContractABI, commitParams.FromBlockToCheckForEvents, toBlock.Number, eventNames, commitParams.JobsCache, commitParams.CollectionsCache) if err != nil { return err } @@ -72,8 +72,8 @@ func CheckForJobAndCollectionEvents(client *ethclient.Client, commitParams *type } // processEvents fetches and processes logs for multiple event types. -func processEvents(client *ethclient.Client, contractABI abi.ABI, fromBlock, toBlock *big.Int, eventNames []string, jobsCache *cache.JobsCache, collectionsCache *cache.CollectionsCache) (*big.Int, error) { - logs, err := getEventLogs(client, fromBlock, toBlock) +func processEvents(rpcParameters rpc.RPCParameters, contractABI abi.ABI, fromBlock, toBlock *big.Int, eventNames []string, jobsCache *cache.JobsCache, collectionsCache *cache.CollectionsCache) (*big.Int, error) { + logs, err := getEventLogs(rpcParameters, fromBlock, toBlock) if err != nil { log.Errorf("Failed to fetch logs: %v", err) return nil, err @@ -86,7 +86,7 @@ func processEvents(client *ethclient.Client, contractABI abi.ABI, fromBlock, toB switch eventName { case core.JobUpdatedEvent, core.JobCreatedEvent: jobId := utils.ConvertHashToUint16(vLog.Topics[1]) - updatedJob, err := utils.UtilsInterface.GetActiveJob(client, jobId) + updatedJob, err := razorUtils.GetActiveJob(rpcParameters, jobId) if err != nil { log.Errorf("Error in getting job with job Id %v: %v", jobId, err) continue @@ -95,7 +95,7 @@ func processEvents(client *ethclient.Client, contractABI abi.ABI, fromBlock, toB jobsCache.UpdateJob(jobId, updatedJob) case core.CollectionUpdatedEvent, core.CollectionCreatedEvent, core.CollectionActivityStatusEvent: collectionId := utils.ConvertHashToUint16(vLog.Topics[1]) - newCollection, err := utils.UtilsInterface.GetCollection(client, collectionId) + newCollection, err := razorUtils.GetCollection(rpcParameters, collectionId) if err != nil { log.Errorf("Error in getting collection with collection Id %v: %v", collectionId, err) continue @@ -112,7 +112,7 @@ func processEvents(client *ethclient.Client, contractABI abi.ABI, fromBlock, toB } // getEventLogs is a utility function to fetch the event logs -func getEventLogs(client *ethclient.Client, fromBlock *big.Int, toBlock *big.Int) ([]Types.Log, error) { +func getEventLogs(rpcParameters rpc.RPCParameters, fromBlock *big.Int, toBlock *big.Int) ([]Types.Log, error) { log.Debugf("Checking for events from block %v to block %v...", fromBlock, toBlock) // Set up the query for filtering logs @@ -125,7 +125,7 @@ func getEventLogs(client *ethclient.Client, fromBlock *big.Int, toBlock *big.Int } // Retrieve the logs - logs, err := clientUtils.FilterLogsWithRetry(client, query) + logs, err := clientUtils.FilterLogsWithRetry(rpcParameters, query) if err != nil { log.Errorf("Error in filter logs: %v", err) return []Types.Log{}, err diff --git a/cmd/importEndpoints.go b/cmd/importEndpoints.go new file mode 100644 index 000000000..040cf5375 --- /dev/null +++ b/cmd/importEndpoints.go @@ -0,0 +1,47 @@ +package cmd + +import ( + "encoding/json" + "github.com/spf13/cobra" + "os" + "path/filepath" + "razor/core" + "razor/utils" +) + +// importEndpointsCmd represents the importEndpoints command +var importEndpointsCmd = &cobra.Command{ + Use: "importEndpoints", + Short: "imports the list of endpoints locally", + Long: `Imports the list of endpoints to $HOME/.rzr directory allowing the user to access/edit it easily. +Example: + ./razor importEndpoints `, + Run: initialiseImportEndpoints, +} + +func initialiseImportEndpoints(cmd *cobra.Command, args []string) { + cmdUtils.ExecuteImportEndpoints() +} + +// ExecuteImportEndpoints imports the list of endpoints from core/endpoints.go to $HOME/.razor directory locally. +func (*UtilsStruct) ExecuteImportEndpoints() { + defaultPath, err := pathUtils.GetDefaultPath() + utils.CheckError("Error in getting default path: ", err) + + // Define the target path for endpoints.json + destFilePath := filepath.Join(defaultPath, "endpoints.json") + + // Serialize the default endpoints to JSON + endpointsData, err := json.MarshalIndent(core.DefaultEndpoints, "", " ") + utils.CheckError("Error in serializing the endpoints: %w", err) + + // Write the JSON to the destination file + err = os.WriteFile(destFilePath, endpointsData, 0644) + utils.CheckError("Error in writing endpoints.json: %w", err) + + log.Infof("Default endpoints successfully imported to %s", destFilePath) +} + +func init() { + rootCmd.AddCommand(importEndpointsCmd) +} diff --git a/cmd/importEndpoints_test.go b/cmd/importEndpoints_test.go new file mode 100644 index 000000000..6a85db8ad --- /dev/null +++ b/cmd/importEndpoints_test.go @@ -0,0 +1,52 @@ +package cmd + +import ( + "encoding/json" + "github.com/stretchr/testify/assert" + "os" + "path/filepath" + "razor/core" + "testing" +) + +func TestExecuteImportEndpoints_WithMockedPath(t *testing.T) { + // Create a temporary directory to mock the default path + tempDir, err := os.MkdirTemp("", "test_default_path") + assert.NoError(t, err, "Temporary directory should be created") + defer os.RemoveAll(tempDir) // Clean up after the test + + SetUpMockInterfaces() + + pathMock.On("GetDefaultPath").Return(tempDir, nil) + + // Call ExecuteImportEndpoints + utils := &UtilsStruct{} + utils.ExecuteImportEndpoints() + + // Verify the file was created in the mocked directory + destFilePath := filepath.Join(tempDir, "endpoints.json") + _, err = os.Stat(destFilePath) + assert.NoError(t, err, "endpoints.json should be created in the mocked directory") + + // Verify the content of the file matches core.DefaultEndpoints + data, err := os.ReadFile(destFilePath) + assert.NoError(t, err, "File should be readable") + + var importedEndpoints []string + err = json.Unmarshal(data, &importedEndpoints) + assert.NoError(t, err, "JSON should be valid") + assert.Equal(t, core.DefaultEndpoints, importedEndpoints, "Imported endpoints should match the defaults") + + // Delete the file after verification + err = os.Remove(destFilePath) + assert.NoError(t, err, "endpoints.json should be deleted successfully") + + // Verify logs + log.Infof("Default endpoints successfully imported to %s", destFilePath) + pathMock.AssertExpectations(t) + + // Confirm the file no longer exists + _, err = os.Stat(destFilePath) + assert.Error(t, err, "endpoints.json should not exist after deletion") + assert.True(t, os.IsNotExist(err), "Error should indicate file does not exist") +} diff --git a/cmd/import_test.go b/cmd/import_test.go index 89b18df31..df095d973 100644 --- a/cmd/import_test.go +++ b/cmd/import_test.go @@ -208,14 +208,16 @@ func TestExecuteImport(t *testing.T) { expectedFatal: true, }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(false) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("ImportAccount").Return(tt.args.account, tt.args.accountErr) cmdUtilsMock.On("GetConfigData").Return(types.Configurations{}, nil) diff --git a/cmd/initTestMocks_test.go b/cmd/initTestMocks_test.go index f410e24a3..b00ecb3bb 100644 --- a/cmd/initTestMocks_test.go +++ b/cmd/initTestMocks_test.go @@ -1,16 +1,28 @@ package cmd import ( + "context" "crypto/ecdsa" "crypto/rand" + "fmt" + "github.com/avast/retry-go" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" "math/big" + "os" + "path/filepath" "razor/cmd/mocks" "razor/path" pathPkgMocks "razor/path/mocks" + "razor/rpc" "razor/utils" utilsPkgMocks "razor/utils/mocks" + "strings" + "testing" + "time" ) var ( @@ -160,6 +172,7 @@ func SetUpMockInterfaces() { pathMock = new(pathPkgMocks.PathInterface) pathUtils = pathMock + path.PathUtilsInterface = pathMock osPathMock = new(pathPkgMocks.OSInterface) path.OSUtilsInterface = osPathMock @@ -167,3 +180,106 @@ func SetUpMockInterfaces() { var privateKey, _ = ecdsa.GenerateKey(crypto.S256(), rand.Reader) var TxnOpts, _ = bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(31000)) // Used any random big int for chain ID + +var rpcManager = rpc.RPCManager{ + BestEndpoint: &rpc.RPCEndpoint{ + Client: ðclient.Client{}, + }, +} +var rpcParameters = rpc.RPCParameters{ + Ctx: context.Background(), + RPCManager: &rpcManager, +} + +func TestInvokeFunctionWithRetryAttempts(t *testing.T) { + tests := []struct { + name string + methodName string + timeout time.Duration + expectError bool + expectedErr string + expectedVals bool + }{ + { + name: "Normal Case - Fast Method", + methodName: "FastMethod", + timeout: 5 * time.Second, + expectError: false, + expectedErr: "", + expectedVals: true, + }, + { + name: "Timeout Case - Slow Method", + methodName: "SlowMethod", + timeout: 0 * time.Second, + expectError: true, + expectedErr: "context deadline exceeded", + expectedVals: false, + }, + } + + // Dummy RPC struct + dummyRPC := &DummyRPC{} + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Set up context with timeout for each test case + ctx, cancel := context.WithTimeout(context.Background(), tt.timeout) + defer cancel() + + SetUpMockInterfaces() + retryUtilsMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(4)) + + localRPCParameters := rpc.RPCParameters{ + Ctx: ctx, + RPCManager: &rpcManager, + } + returnedValues, err := utils.InvokeFunctionWithRetryAttempts(localRPCParameters, dummyRPC, tt.methodName) + fmt.Println("Error: ", err) + + if tt.expectError { + assert.Error(t, err) + assert.True(t, strings.Contains(err.Error(), tt.expectedErr), "Expected error to contain: %v, but got: %v", tt.expectedErr, err.Error()) + } else { + assert.NoError(t, err) + } + + if tt.expectedVals { + assert.NotNil(t, returnedValues) + } else { + assert.Nil(t, returnedValues) + } + }) + } +} + +// Dummy interface with methods +type DummyRPC struct{} + +// A fast method that simulates successful execution, added client as the parameter because generic retry functions expects client as the first parameter +func (d *DummyRPC) FastMethod(client *ethclient.Client) error { + return nil +} + +// A slow method that simulates a long-running process, added client as the parameter because generic retry functions expects client as the first parameter +func (d *DummyRPC) SlowMethod(client *ethclient.Client) error { + fmt.Println("Sleeping...") + time.Sleep(3 * time.Second) // Simulate delay to trigger timeout + return nil +} + +func setupTestEndpointsEnvironment() { + var testDir = "/tmp/test_rzr" + pathMock.On("GetDefaultPath").Return(testDir, nil) + err := os.MkdirAll(testDir, 0755) + if err != nil { + log.Fatalf("failed to create test directory: %s", err.Error()) + } + + mockEndpoints := `["https://testnet.skalenodes.com/v1/juicy-low-small-testnet"]` + mockFilePath := filepath.Join(testDir, "endpoints.json") + err = os.WriteFile(mockFilePath, []byte(mockEndpoints), 0644) + if err != nil { + log.Fatalf("failed to write mock endpoints.json: %s", err.Error()) + } +} diff --git a/cmd/initiateWithdraw.go b/cmd/initiateWithdraw.go index f1393c452..afaabab28 100644 --- a/cmd/initiateWithdraw.go +++ b/cmd/initiateWithdraw.go @@ -4,16 +4,14 @@ package cmd import ( "errors" "math/big" - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/cobra" "github.com/spf13/pflag" ) @@ -33,49 +31,26 @@ Example: //This function sets the flags appropriately and executes the InitiateWithdraw function func (*UtilsStruct) ExecuteInitiateWithdraw(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteInitiateWithdraw: Config: %+v: ", config) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - log.Debug("ExecuteInitiateWithdraw: Address: ", address) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) - - stakerId, err := razorUtils.AssignStakerId(flagSet, client, address) + stakerId, err := razorUtils.AssignStakerId(rpcParameters, flagSet, account.Address) utils.CheckError("Error in fetching stakerId: ", err) log.Debug("ExecuteInitiateWithdraw: Staker Id: ", stakerId) - log.Debugf("ExecuteInitiateWithdraw: Calling HandleUnstakeLock() with arguments account address: %s, stakerId: %d", address, stakerId) - txn, err := cmdUtils.HandleUnstakeLock(client, account, config, stakerId) + log.Debugf("ExecuteInitiateWithdraw: Calling HandleUnstakeLock() with arguments account address: %s, stakerId: %d", account.Address, stakerId) + txn, err := cmdUtils.HandleUnstakeLock(rpcParameters, account, config, stakerId) utils.CheckError("InitiateWithdraw error: ", err) if txn != core.NilHash { - err := razorUtils.WaitForBlockCompletion(client, txn.Hex()) + err := razorUtils.WaitForBlockCompletion(rpcParameters, txn.Hex()) utils.CheckError("Error in WaitForBlockCompletion for initiateWithdraw: ", err) } } //This function handles the unstake lock -func (*UtilsStruct) HandleUnstakeLock(client *ethclient.Client, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) { - unstakeLock, err := razorUtils.GetLock(client, account.Address, stakerId, 0) +func (*UtilsStruct) HandleUnstakeLock(rpcParameters rpc.RPCParameters, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) { + unstakeLock, err := razorUtils.GetLock(rpcParameters, account.Address, stakerId, 0) if err != nil { log.Error("Error in fetching unstakeLock") return core.NilHash, err @@ -87,7 +62,7 @@ func (*UtilsStruct) HandleUnstakeLock(client *ethclient.Client, account types.Ac return core.NilHash, errors.New("unstake Razors before withdrawing") } - withdrawInitiationPeriod, err := razorUtils.GetWithdrawInitiationPeriod(client) + withdrawInitiationPeriod, err := razorUtils.GetWithdrawInitiationPeriod(rpcParameters) if err != nil { log.Error("Error in fetching withdraw release period") return core.NilHash, err @@ -96,7 +71,7 @@ func (*UtilsStruct) HandleUnstakeLock(client *ethclient.Client, account types.Ac withdrawBefore := big.NewInt(0).Add(unstakeLock.UnlockAfter, big.NewInt(int64(withdrawInitiationPeriod))) log.Debug("HandleUnstakeLock: Withdraw before epoch: ", withdrawBefore) - epoch, err := razorUtils.GetEpoch(client) + epoch, err := razorUtils.GetEpoch(rpcParameters) if err != nil { log.Error("Error in fetching epoch") return core.NilHash, err @@ -116,14 +91,13 @@ func (*UtilsStruct) HandleUnstakeLock(client *ethclient.Client, account types.Ac } log.Debug("Waiting for appropriate state to initiate withdraw...") - _, err = cmdUtils.WaitForAppropriateState(client, "initiateWithdraw", 0, 1, 4) + _, err = cmdUtils.WaitForAppropriateState(rpcParameters, "initiateWithdraw", 0, 1, 4) if err != nil { log.Error("Error in fetching state: ", err) return core.NilHash, err } txnArgs := types.TransactionOptions{ - Client: client, ChainId: core.ChainId, Config: configurations, ContractAddress: core.StakeManagerAddress, @@ -132,18 +106,27 @@ func (*UtilsStruct) HandleUnstakeLock(client *ethclient.Client, account types.Ac Parameters: []interface{}{stakerId}, Account: account, } - txnOpts := razorUtils.GetTxnOpts(txnArgs) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) + if err != nil { + return core.NilHash, err + } if big.NewInt(int64(epoch)).Cmp(unstakeLock.UnlockAfter) >= 0 && big.NewInt(int64(epoch)).Cmp(withdrawBefore) <= 0 { log.Debug("Calling InitiateWithdraw() with arguments stakerId: ", stakerId) - return cmdUtils.InitiateWithdraw(client, txnOpts, stakerId) + return cmdUtils.InitiateWithdraw(rpcParameters, txnOpts, stakerId) } return core.NilHash, errors.New("unstakeLock period not over yet! Please try after some time") } //This function initiate withdraw for your razors once you've unstaked -func (*UtilsStruct) InitiateWithdraw(client *ethclient.Client, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) { +func (*UtilsStruct) InitiateWithdraw(rpcParameters rpc.RPCParameters, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) { log.Info("Initiating withdrawal of funds...") + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debug("Executing InitiateWithdraw transaction for stakerId = ", stakerId) txn, err := stakeManagerUtils.InitiateWithdraw(client, txnOpts, stakerId) if err != nil { diff --git a/cmd/initiateWithdraw_test.go b/cmd/initiateWithdraw_test.go index ac827497f..f7da08e39 100644 --- a/cmd/initiateWithdraw_test.go +++ b/cmd/initiateWithdraw_test.go @@ -4,13 +4,14 @@ import ( "crypto/ecdsa" "crypto/rand" "errors" - "github.com/ethereum/go-ethereum/crypto" "math/big" "razor/accounts" "razor/core" "razor/core/types" "testing" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" @@ -20,7 +21,6 @@ import ( ) func TestHandleUnstakeLock(t *testing.T) { - var client *ethclient.Client var account types.Account var configurations types.Configurations var stakerId uint32 @@ -35,6 +35,7 @@ func TestHandleUnstakeLock(t *testing.T) { epoch uint32 epochErr error time string + txnOptsErr error withdrawHash common.Hash withdrawErr error } @@ -174,21 +175,34 @@ func TestHandleUnstakeLock(t *testing.T) { want: core.NilHash, wantErr: nil, }, + { + name: "Test 11: When there is an error in getting txnOpts", + args: args{ + lock: types.Locks{ + UnlockAfter: big.NewInt(4), + }, + withdrawReleasePeriod: 4, + epoch: 5, + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - cmdUtilsMock.On("WaitForAppropriateState", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.state, tt.args.stateErr) - utilsMock.On("GetLock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string"), mock.AnythingOfType("uint32"), mock.Anything).Return(tt.args.lock, tt.args.lockErr) - utilsMock.On("GetWithdrawInitiationPeriod", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.withdrawReleasePeriod, tt.args.withdrawReleasePeriodErr) - utilsMock.On("GetEpoch", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epoch, tt.args.epochErr) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + cmdUtilsMock.On("WaitForAppropriateState", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.state, tt.args.stateErr) + utilsMock.On("GetLock", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.lock, tt.args.lockErr) + utilsMock.On("GetWithdrawInitiationPeriod", mock.Anything, mock.Anything).Return(tt.args.withdrawReleasePeriod, tt.args.withdrawReleasePeriodErr) + utilsMock.On("GetEpoch", mock.Anything).Return(tt.args.epoch, tt.args.epochErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) cmdUtilsMock.On("InitiateWithdraw", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.withdrawHash, tt.args.withdrawErr) utilsMock.On("SecondsToReadableTime", mock.AnythingOfType("int")).Return(tt.args.time) utils := &UtilsStruct{} - got, err := utils.HandleUnstakeLock(client, account, configurations, stakerId) + got, err := utils.HandleUnstakeLock(rpcParameters, account, configurations, stakerId) if got != tt.want { t.Errorf("Txn hash for withdrawFunds function, got = %v, want = %v", got, tt.want) } @@ -210,7 +224,6 @@ func TestWithdraw(t *testing.T) { privateKey, _ := ecdsa.GenerateKey(crypto.S256(), rand.Reader) txnOpts, _ := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1)) - var client *ethclient.Client var stakerId uint32 type args struct { @@ -253,7 +266,7 @@ func TestWithdraw(t *testing.T) { transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.InitiateWithdraw(client, txnOpts, stakerId) + got, err := utils.InitiateWithdraw(rpcParameters, txnOpts, stakerId) if got != tt.want { t.Errorf("Txn hash for withdraw function, got = %v, want = %v", got, tt.want) } @@ -353,24 +366,26 @@ func TestExecuteWithdraw(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("AssignPassword", flagSet).Return(tt.args.password) utilsMock.On("CheckPassword", mock.Anything).Return(nil) utilsMock.On("AccountManagerForKeystore").Return(&accounts.AccountManager{}, nil) flagSetMock.On("GetStringAddress", flagSet).Return(tt.args.address, tt.args.addressErr) - utilsMock.On("AssignStakerId", flagSet, mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) + utilsMock.On("AssignStakerId", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) cmdUtilsMock.On("HandleUnstakeLock", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.withdrawHash, tt.args.withdrawErr) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) utils := &UtilsStruct{} fatal = false diff --git a/cmd/interface.go b/cmd/interface.go index 51a1e127d..16c6ee2ce 100644 --- a/cmd/interface.go +++ b/cmd/interface.go @@ -2,13 +2,14 @@ package cmd import ( - "context" "crypto/ecdsa" "math/big" + "razor/block" "razor/cache" "razor/core/types" "razor/path" "razor/pkg/bindings" + "razor/rpc" "time" "github.com/ethereum/go-ethereum/accounts" @@ -64,11 +65,6 @@ type StakeManagerInterface interface { UpdateCommission(client *ethclient.Client, opts *bind.TransactOpts, commission uint8) (*Types.Transaction, error) ApproveUnstake(client *ethclient.Client, opts *bind.TransactOpts, stakerTokenAddress common.Address, amount *big.Int) (*Types.Transaction, error) ClaimStakerReward(client *ethclient.Client, opts *bind.TransactOpts) (*Types.Transaction, error) - - //Getter methods - StakerInfo(client *ethclient.Client, opts *bind.CallOpts, stakerId uint32) (types.Staker, error) - GetMaturity(client *ethclient.Client, opts *bind.CallOpts, age uint32) (uint16, error) - GetBountyLock(client *ethclient.Client, opts *bind.CallOpts, bountyId uint32) (types.BountyLock, error) } type KeystoreInterface interface { @@ -84,9 +80,8 @@ type BlockManagerInterface interface { DisputeOnOrderOfIds(client *ethclient.Client, opts *bind.TransactOpts, epoch uint32, blockIndex uint8, index0 *big.Int, index1 *big.Int) (*Types.Transaction, error) DisputeCollectionIdShouldBeAbsent(client *ethclient.Client, opts *bind.TransactOpts, epoch uint32, blockIndex uint8, id uint16, positionOfCollectionInBlock *big.Int) (*Types.Transaction, error) DisputeCollectionIdShouldBePresent(client *ethclient.Client, opts *bind.TransactOpts, epoch uint32, blockIndex uint8, id uint16) (*Types.Transaction, error) - GiveSorted(blockManager *bindings.BlockManager, opts *bind.TransactOpts, epoch uint32, leafId uint16, sortedValues []*big.Int) (*Types.Transaction, error) - ResetDispute(blockManager *bindings.BlockManager, opts *bind.TransactOpts, epoch uint32) (*Types.Transaction, error) - Disputes(client *ethclient.Client, opts *bind.CallOpts, epoch uint32, address common.Address) (types.DisputesStruct, error) + GiveSorted(client *ethclient.Client, opts *bind.TransactOpts, epoch uint32, leafId uint16, sortedValues []*big.Int) (*Types.Transaction, error) + ResetDispute(client *ethclient.Client, opts *bind.TransactOpts, epoch uint32) (*Types.Transaction, error) } type VoteManagerInterface interface { @@ -95,7 +90,6 @@ type VoteManagerInterface interface { } type TokenManagerInterface interface { - Allowance(client *ethclient.Client, opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) Approve(client *ethclient.Client, opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*Types.Transaction, error) Transfer(client *ethclient.Client, opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*Types.Transaction, error) } @@ -147,7 +141,6 @@ type FlagSetInterface interface { type UtilsCmdInterface interface { SetConfig(flagSet *pflag.FlagSet) error GetProvider() (string, error) - GetAlternateProvider() (string, error) GetMultiplier() (float32, error) GetWaitTime() (int32, error) GetGasPrice() (int32, error) @@ -162,95 +155,95 @@ type UtilsCmdInterface interface { GetLogFileMaxAge() (int, error) GetConfigData() (types.Configurations, error) ExecuteClaimBounty(flagSet *pflag.FlagSet) - ClaimBounty(config types.Configurations, client *ethclient.Client, redeemBountyInput types.RedeemBountyInput) (common.Hash, error) - ClaimBlockReward(options types.TransactionOptions) (common.Hash, error) - GetSalt(client *ethclient.Client, epoch uint32) ([32]byte, error) - HandleCommitState(client *ethclient.Client, epoch uint32, seed []byte, commitParams *types.CommitParams, rogueData types.Rogue) (types.CommitData, error) - Commit(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, latestHeader *Types.Header, seed []byte, values []*big.Int) (common.Hash, error) + ClaimBounty(rpcParameters rpc.RPCParameters, config types.Configurations, redeemBountyInput types.RedeemBountyInput) (common.Hash, error) + ClaimBlockReward(rpcParameters rpc.RPCParameters, options types.TransactionOptions) (common.Hash, error) + GetSalt(rpcParameters rpc.RPCParameters, epoch uint32) ([32]byte, error) + HandleCommitState(rpcParameters rpc.RPCParameters, epoch uint32, seed []byte, commitParams *types.CommitParams, rogueData types.Rogue) (types.CommitData, error) + Commit(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, latestHeader *Types.Header, stateBuffer uint64, commitment [32]byte) (common.Hash, error) ListAccounts() ([]accounts.Account, error) AssignAmountInWei(flagSet *pflag.FlagSet) (*big.Int, error) ExecuteTransfer(flagSet *pflag.FlagSet) - Transfer(client *ethclient.Client, config types.Configurations, transferInput types.TransferInput) (common.Hash, error) - CheckForLastCommitted(client *ethclient.Client, staker bindings.StructsStaker, epoch uint32) error - Reveal(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, latestHeader *Types.Header, commitData types.CommitData, signature []byte) (common.Hash, error) + Transfer(rpcParameters rpc.RPCParameters, config types.Configurations, transferInput types.TransferInput) (common.Hash, error) + CheckForLastCommitted(rpcParameters rpc.RPCParameters, staker bindings.StructsStaker, epoch uint32) error + Reveal(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, latestHeader *Types.Header, stateBuffer uint64, commitData types.CommitData, signature []byte) (common.Hash, error) GenerateTreeRevealData(merkleTree [][][]byte, commitData types.CommitData) bindings.StructsMerkleTree - IndexRevealEventsOfCurrentEpoch(client *ethclient.Client, blockNumber *big.Int, epoch uint32) ([]types.RevealedStruct, error) + IndexRevealEventsOfCurrentEpoch(rpcParameters rpc.RPCParameters, blockNumber *big.Int, epoch uint32) ([]types.RevealedStruct, error) ExecuteCreateJob(flagSet *pflag.FlagSet) - CreateJob(client *ethclient.Client, config types.Configurations, jobInput types.CreateJobInput) (common.Hash, error) + CreateJob(rpcParameter rpc.RPCParameters, config types.Configurations, jobInput types.CreateJobInput) (common.Hash, error) ExecuteCreateCollection(flagSet *pflag.FlagSet) - CreateCollection(client *ethclient.Client, config types.Configurations, collectionInput types.CreateCollectionInput) (common.Hash, error) - GetEpochAndState(client *ethclient.Client) (uint32, int64, error) - WaitForAppropriateState(client *ethclient.Client, action string, states ...int) (uint32, error) + CreateCollection(rpcParameters rpc.RPCParameters, config types.Configurations, collectionInput types.CreateCollectionInput) (common.Hash, error) + GetEpochAndState(rpcParameter rpc.RPCParameters) (uint32, int64, error) + WaitForAppropriateState(rpcParameter rpc.RPCParameters, action string, states ...int) (uint32, error) ExecuteJobList(flagSet *pflag.FlagSet) - GetJobList(client *ethclient.Client) error + GetJobList(rpcParameters rpc.RPCParameters) error ExecuteUnstake(flagSet *pflag.FlagSet) - Unstake(config types.Configurations, client *ethclient.Client, input types.UnstakeInput) (common.Hash, error) - ApproveUnstake(client *ethclient.Client, stakerTokenAddress common.Address, txnArgs types.TransactionOptions) (common.Hash, error) + Unstake(rpcParameters rpc.RPCParameters, config types.Configurations, input types.UnstakeInput) (common.Hash, error) + ApproveUnstake(rpcParameters rpc.RPCParameters, stakerTokenAddress common.Address, txnArgs types.TransactionOptions) (common.Hash, error) ExecuteInitiateWithdraw(flagSet *pflag.FlagSet) ExecuteUnlockWithdraw(flagSet *pflag.FlagSet) - InitiateWithdraw(client *ethclient.Client, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) - UnlockWithdraw(client *ethclient.Client, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) - HandleUnstakeLock(client *ethclient.Client, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) - HandleWithdrawLock(client *ethclient.Client, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) + InitiateWithdraw(rpcParameters rpc.RPCParameters, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) + UnlockWithdraw(rpcParameters rpc.RPCParameters, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) + HandleUnstakeLock(rpcParameters rpc.RPCParameters, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) + HandleWithdrawLock(rpcParameters rpc.RPCParameters, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) ExecuteUpdateJob(flagSet *pflag.FlagSet) - UpdateJob(client *ethclient.Client, config types.Configurations, jobInput types.CreateJobInput, jobId uint16) (common.Hash, error) - WaitIfCommitState(client *ethclient.Client, action string) (uint32, error) + UpdateJob(rpcParameters rpc.RPCParameters, config types.Configurations, jobInput types.CreateJobInput, jobId uint16) (common.Hash, error) + WaitIfCommitState(rpcParameter rpc.RPCParameters, action string) (uint32, error) ExecuteCollectionList(flagSet *pflag.FlagSet) - GetCollectionList(client *ethclient.Client) error + GetCollectionList(rpcParameters rpc.RPCParameters) error ExecuteStakerinfo(flagSet *pflag.FlagSet) ExecuteSetDelegation(flagSet *pflag.FlagSet) - SetDelegation(client *ethclient.Client, config types.Configurations, delegationInput types.SetDelegationInput) (common.Hash, error) - GetStakerInfo(client *ethclient.Client, stakerId uint32) error + SetDelegation(rpcParameters rpc.RPCParameters, config types.Configurations, delegationInput types.SetDelegationInput) (common.Hash, error) + GetStakerInfo(rpcParameters rpc.RPCParameters, stakerId uint32) error ExecuteUpdateCollection(flagSet *pflag.FlagSet) - UpdateCollection(client *ethclient.Client, config types.Configurations, collectionInput types.CreateCollectionInput, collectionId uint16) (common.Hash, error) - MakeBlock(client *ethclient.Client, blockNumber *big.Int, epoch uint32, rogueData types.Rogue) ([]*big.Int, []uint16, *types.RevealedDataMaps, error) + UpdateCollection(rpcParameters rpc.RPCParameters, config types.Configurations, collectionInput types.CreateCollectionInput, collectionId uint16) (common.Hash, error) + MakeBlock(rpcParameters rpc.RPCParameters, blockNumber *big.Int, epoch uint32, rogueData types.Rogue) ([]*big.Int, []uint16, *types.RevealedDataMaps, error) IsElectedProposer(proposer types.ElectedProposer, currentStakerStake *big.Int) bool - GetSortedRevealedValues(client *ethclient.Client, blockNumber *big.Int, epoch uint32) (*types.RevealedDataMaps, error) - GetIteration(client *ethclient.Client, proposer types.ElectedProposer, bufferPercent int32) int - Propose(client *ethclient.Client, config types.Configurations, account types.Account, staker bindings.StructsStaker, epoch uint32, latestHeader *Types.Header, rogueData types.Rogue) error - GiveSorted(client *ethclient.Client, blockManager *bindings.BlockManager, txnArgs types.TransactionOptions, epoch uint32, assetId uint16, sortedStakers []*big.Int) error - GetLocalMediansData(client *ethclient.Client, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue) (types.ProposeFileData, error) - CheckDisputeForIds(client *ethclient.Client, transactionOpts types.TransactionOptions, epoch uint32, blockIndex uint8, idsInProposedBlock []uint16, revealedCollectionIds []uint16) (*Types.Transaction, error) - Dispute(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, blockIndex uint8, proposedBlock bindings.StructsBlock, leafId uint16, sortedValues []*big.Int) error - GetCollectionIdPositionInBlock(client *ethclient.Client, leafId uint16, proposedBlock bindings.StructsBlock) *big.Int - HandleDispute(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue, backupNodeActionsToIgnore []string) error + GetSortedRevealedValues(rpcParameters rpc.RPCParameters, blockNumber *big.Int, epoch uint32) (*types.RevealedDataMaps, error) + GetIteration(rpcParameters rpc.RPCParameters, proposer types.ElectedProposer, bufferPercent int32) int + Propose(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, staker bindings.StructsStaker, epoch uint32, latestHeader *Types.Header, stateBuffer uint64, rogueData types.Rogue) error + GiveSorted(rpcParameters rpc.RPCParameters, txnArgs types.TransactionOptions, epoch uint32, assetId uint16, sortedStakers []*big.Int) error + GetLocalMediansData(rpcParameters rpc.RPCParameters, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue) (types.ProposeFileData, error) + CheckDisputeForIds(rpcParameters rpc.RPCParameters, transactionOpts types.TransactionOptions, epoch uint32, blockIndex uint8, idsInProposedBlock []uint16, revealedCollectionIds []uint16) (*Types.Transaction, error) + Dispute(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, blockIndex uint8, proposedBlock bindings.StructsBlock, leafId uint16, sortedValues []*big.Int) error + GetCollectionIdPositionInBlock(rpcParameters rpc.RPCParameters, leafId uint16, proposedBlock bindings.StructsBlock) *big.Int + HandleDispute(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue, backupNodeActionsToIgnore []string) error ExecuteExtendLock(flagSet *pflag.FlagSet) - ResetUnstakeLock(client *ethclient.Client, config types.Configurations, extendLockInput types.ExtendLockInput) (common.Hash, error) - CheckCurrentStatus(client *ethclient.Client, collectionId uint16) (bool, error) + ResetUnstakeLock(rpcParameters rpc.RPCParameters, config types.Configurations, extendLockInput types.ExtendLockInput) (common.Hash, error) ExecuteModifyCollectionStatus(flagSet *pflag.FlagSet) - ModifyCollectionStatus(client *ethclient.Client, config types.Configurations, modifyCollectionInput types.ModifyCollectionInput) (common.Hash, error) - Approve(txnArgs types.TransactionOptions) (common.Hash, error) + ModifyCollectionStatus(rpcParameters rpc.RPCParameters, config types.Configurations, modifyCollectionInput types.ModifyCollectionInput) (common.Hash, error) + Approve(rpcParameters rpc.RPCParameters, txnArgs types.TransactionOptions) (common.Hash, error) ExecuteDelegate(flagSet *pflag.FlagSet) - Delegate(txnArgs types.TransactionOptions, stakerId uint32) (common.Hash, error) + Delegate(rpcParameters rpc.RPCParameters, txnArgs types.TransactionOptions, stakerId uint32) (common.Hash, error) ExecuteCreate(flagSet *pflag.FlagSet) Create(password string) (accounts.Account, error) ExecuteImport(flagSet *pflag.FlagSet) ImportAccount() (accounts.Account, error) ExecuteUpdateCommission(flagSet *pflag.FlagSet) - UpdateCommission(config types.Configurations, client *ethclient.Client, updateCommissionInput types.UpdateCommissionInput) error - GetBiggestStakeAndId(client *ethclient.Client, epoch uint32) (*big.Int, uint32, error) - GetSmallestStakeAndId(client *ethclient.Client, epoch uint32) (*big.Int, uint32, error) - StakeCoins(txnArgs types.TransactionOptions) (common.Hash, error) + UpdateCommission(rpcParameters rpc.RPCParameters, config types.Configurations, updateCommissionInput types.UpdateCommissionInput) error + GetBiggestStakeAndId(rpcParameters rpc.RPCParameters, epoch uint32) (*big.Int, uint32, error) + GetSmallestStakeAndId(rpcParameters rpc.RPCParameters, epoch uint32) (*big.Int, uint32, error) + StakeCoins(rpcParameters rpc.RPCParameters, txnArgs types.TransactionOptions) (common.Hash, error) CalculateSecret(account types.Account, epoch uint32, keystorePath string, chainId *big.Int) ([]byte, []byte, error) - HandleBlock(client *ethclient.Client, account types.Account, stakerId uint32, header *Types.Header, config types.Configurations, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) + HandleBlock(rpcParameters rpc.RPCParameters, account types.Account, stakerId uint32, header *Types.Header, config types.Configurations, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) ExecuteVote(flagSet *pflag.FlagSet) - Vote(ctx context.Context, config types.Configurations, client *ethclient.Client, account types.Account, stakerId uint32, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) error + Vote(rpcParameters rpc.RPCParameters, blockMonitor *block.BlockMonitor, config types.Configurations, account types.Account, stakerId uint32, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) error HandleExit() ExecuteListAccounts(flagSet *pflag.FlagSet) ClaimCommission(flagSet *pflag.FlagSet) ExecuteStake(flagSet *pflag.FlagSet) - InitiateCommit(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, stakerId uint32, latestHeader *Types.Header, commitParams *types.CommitParams, rogueData types.Rogue) error - InitiateReveal(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *Types.Header, rogueData types.Rogue) error - InitiatePropose(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *Types.Header, rogueData types.Rogue) error - GetBountyIdFromEvents(client *ethclient.Client, blockNumber *big.Int, bountyHunter string) (uint32, error) - HandleClaimBounty(client *ethclient.Client, config types.Configurations, account types.Account) error + InitiateCommit(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, stakerId uint32, latestHeader *Types.Header, commitParams *types.CommitParams, stateBuffer uint64, rogueData types.Rogue) error + InitiateReveal(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *Types.Header, stateBuffer uint64, rogueData types.Rogue) error + InitiatePropose(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *Types.Header, stateBuffer uint64, rogueData types.Rogue) error + GetBountyIdFromEvents(rpcParameters rpc.RPCParameters, blockNumber *big.Int, bountyHunter string) (uint32, error) + HandleClaimBounty(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account) error ExecuteContractAddresses(flagSet *pflag.FlagSet) ContractAddresses() - ResetDispute(client *ethclient.Client, blockManager *bindings.BlockManager, txnOpts *bind.TransactOpts, epoch uint32) - StoreBountyId(client *ethclient.Client, account types.Account) error - CheckToDoResetDispute(client *ethclient.Client, blockManager *bindings.BlockManager, txnOpts *bind.TransactOpts, epoch uint32, sortedValues []*big.Int) - InitJobAndCollectionCache(client *ethclient.Client) (*cache.JobsCache, *cache.CollectionsCache, *big.Int, error) - BatchGetStakeSnapshotCalls(client *ethclient.Client, epoch uint32, numberOfStakers uint32) ([]*big.Int, error) + ResetDispute(rpcParameters rpc.RPCParameters, txnOpts *bind.TransactOpts, epoch uint32) + StoreBountyId(rpcParameters rpc.RPCParameters, account types.Account) error + CheckToDoResetDispute(rpcParameters rpc.RPCParameters, txnOpts *bind.TransactOpts, epoch uint32, sortedValues []*big.Int) + InitJobAndCollectionCache(rpcParameters rpc.RPCParameters) (*cache.JobsCache, *cache.CollectionsCache, *big.Int, error) + BatchGetStakeSnapshotCalls(rpcParameters rpc.RPCParameters, epoch uint32, numberOfStakers uint32) ([]*big.Int, error) + ExecuteImportEndpoints() } type TransactionInterface interface { diff --git a/cmd/jobList.go b/cmd/jobList.go index 828583238..e11447180 100644 --- a/cmd/jobList.go +++ b/cmd/jobList.go @@ -2,12 +2,11 @@ package cmd import ( - "github.com/ethereum/go-ethereum/ethclient" "github.com/olekukonko/tablewriter" "github.com/spf13/cobra" "github.com/spf13/pflag" "os" - "razor/logger" + "razor/rpc" "razor/utils" "strconv" ) @@ -30,21 +29,17 @@ func initialiseJobList(cmd *cobra.Command, args []string) { //This function sets the flags appropriately and executes the GetJobList function func (*UtilsStruct) ExecuteJobList(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteJobList: Config: %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - logger.SetLoggerParameters(client, "") + _, rpcParameters, _, _, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) log.Debug("ExecuteJobList: Calling JobList()...") - err = cmdUtils.GetJobList(client) + err = cmdUtils.GetJobList(rpcParameters) utils.CheckError("Error in getting job list: ", err) } //This function provides the list of all jobs -func (*UtilsStruct) GetJobList(client *ethclient.Client) error { - jobs, err := razorUtils.GetJobs(client) +func (*UtilsStruct) GetJobList(rpcParameters rpc.RPCParameters) error { + jobs, err := razorUtils.GetJobs(rpcParameters) log.Debugf("JobList: Jobs: %+v", jobs) if err != nil { return err diff --git a/cmd/jobList_test.go b/cmd/jobList_test.go index ba5d19559..6bc9c64df 100644 --- a/cmd/jobList_test.go +++ b/cmd/jobList_test.go @@ -11,7 +11,6 @@ import ( ) func TestGetJobList(t *testing.T) { - var client *ethclient.Client type fields struct { razorUtils Utils } @@ -31,7 +30,6 @@ func TestGetJobList(t *testing.T) { } type args struct { - client *ethclient.Client jobList []bindings.StructsJob jobListErr error } @@ -45,7 +43,6 @@ func TestGetJobList(t *testing.T) { name: "Test 1: When jobList executes properly", fields: testUtils, args: args{ - client: client, jobList: jobListArray, jobListErr: nil, }, @@ -56,7 +53,6 @@ func TestGetJobList(t *testing.T) { name: "Test 2: When there is a error fetching job list ", fields: testUtils, args: args{ - client: client, jobListErr: errors.New("error in fetching job list"), }, wantErr: errors.New("error in fetching job list"), @@ -66,10 +62,10 @@ func TestGetJobList(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetJobs", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.jobList, tt.args.jobListErr) + utilsMock.On("GetJobs", mock.Anything, mock.Anything).Return(tt.args.jobList, tt.args.jobListErr) utils := &UtilsStruct{} - err := utils.GetJobList(tt.args.client) + err := utils.GetJobList(rpcParameters) if err == nil || tt.wantErr == nil { if err != tt.wantErr { @@ -127,18 +123,20 @@ func TestExecuteJobList(t *testing.T) { expectedFatal: true, }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(false) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - cmdUtilsMock.On("GetJobList", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.jobListErr) + cmdUtilsMock.On("GetJobList", mock.Anything).Return(tt.args.jobListErr) utils := &UtilsStruct{} fatal = false diff --git a/cmd/listAccounts.go b/cmd/listAccounts.go index c0505fde1..514b0c7d4 100644 --- a/cmd/listAccounts.go +++ b/cmd/listAccounts.go @@ -26,12 +26,6 @@ func initialiseListAccounts(cmd *cobra.Command, args []string) { //This function sets the flag appropriately and executes the ListAccounts function func (*UtilsStruct) ExecuteListAccounts(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - log.Debug("ExecuteListAccounts: Calling ListAccounts()...") allAccounts, err := cmdUtils.ListAccounts() utils.CheckError("ListAccounts error: ", err) diff --git a/cmd/listAccounts_test.go b/cmd/listAccounts_test.go index 9f0d74f9e..2e0ba284f 100644 --- a/cmd/listAccounts_test.go +++ b/cmd/listAccounts_test.go @@ -119,9 +119,9 @@ func TestExecuteListAccounts(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() diff --git a/cmd/mocks/abi_interface.go b/cmd/mocks/abi_interface.go index 5545d651c..9f888d8d4 100644 --- a/cmd/mocks/abi_interface.go +++ b/cmd/mocks/abi_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -18,6 +18,10 @@ func (_m *AbiInterface) Unpack(_a0 abi.ABI, name string, data []byte) ([]interfa ret := _m.Called(_a0, name, data) var r0 []interface{} + var r1 error + if rf, ok := ret.Get(0).(func(abi.ABI, string, []byte) ([]interface{}, error)); ok { + return rf(_a0, name, data) + } if rf, ok := ret.Get(0).(func(abi.ABI, string, []byte) []interface{}); ok { r0 = rf(_a0, name, data) } else { @@ -26,7 +30,6 @@ func (_m *AbiInterface) Unpack(_a0 abi.ABI, name string, data []byte) ([]interfa } } - var r1 error if rf, ok := ret.Get(1).(func(abi.ABI, string, []byte) error); ok { r1 = rf(_a0, name, data) } else { @@ -36,13 +39,12 @@ func (_m *AbiInterface) Unpack(_a0 abi.ABI, name string, data []byte) ([]interfa return r0, r1 } -type mockConstructorTestingTNewAbiInterface interface { +// NewAbiInterface creates a new instance of AbiInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAbiInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewAbiInterface creates a new instance of AbiInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewAbiInterface(t mockConstructorTestingTNewAbiInterface) *AbiInterface { +}) *AbiInterface { mock := &AbiInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/asset_manager_interface.go b/cmd/mocks/asset_manager_interface.go index d4f3304fc..ea2dc6031 100644 --- a/cmd/mocks/asset_manager_interface.go +++ b/cmd/mocks/asset_manager_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -22,6 +22,10 @@ func (_m *AssetManagerInterface) CreateCollection(client *ethclient.Client, opts ret := _m.Called(client, opts, tolerance, power, aggregationMethod, jobIDs, name) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, int8, uint32, []uint16, string) (*types.Transaction, error)); ok { + return rf(client, opts, tolerance, power, aggregationMethod, jobIDs, name) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, int8, uint32, []uint16, string) *types.Transaction); ok { r0 = rf(client, opts, tolerance, power, aggregationMethod, jobIDs, name) } else { @@ -30,7 +34,6 @@ func (_m *AssetManagerInterface) CreateCollection(client *ethclient.Client, opts } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, int8, uint32, []uint16, string) error); ok { r1 = rf(client, opts, tolerance, power, aggregationMethod, jobIDs, name) } else { @@ -45,6 +48,10 @@ func (_m *AssetManagerInterface) CreateJob(client *ethclient.Client, opts *bind. ret := _m.Called(client, opts, weight, power, selectorType, name, selector, url) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint8, int8, uint8, string, string, string) (*types.Transaction, error)); ok { + return rf(client, opts, weight, power, selectorType, name, selector, url) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint8, int8, uint8, string, string, string) *types.Transaction); ok { r0 = rf(client, opts, weight, power, selectorType, name, selector, url) } else { @@ -53,7 +60,6 @@ func (_m *AssetManagerInterface) CreateJob(client *ethclient.Client, opts *bind. } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint8, int8, uint8, string, string, string) error); ok { r1 = rf(client, opts, weight, power, selectorType, name, selector, url) } else { @@ -68,13 +74,16 @@ func (_m *AssetManagerInterface) GetActiveStatus(client *ethclient.Client, opts ret := _m.Called(client, opts, id) var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.CallOpts, uint16) (bool, error)); ok { + return rf(client, opts, id) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.CallOpts, uint16) bool); ok { r0 = rf(client, opts, id) } else { r0 = ret.Get(0).(bool) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.CallOpts, uint16) error); ok { r1 = rf(client, opts, id) } else { @@ -89,6 +98,10 @@ func (_m *AssetManagerInterface) SetCollectionStatus(client *ethclient.Client, o ret := _m.Called(client, opts, assetStatus, id) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, bool, uint16) (*types.Transaction, error)); ok { + return rf(client, opts, assetStatus, id) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, bool, uint16) *types.Transaction); ok { r0 = rf(client, opts, assetStatus, id) } else { @@ -97,7 +110,6 @@ func (_m *AssetManagerInterface) SetCollectionStatus(client *ethclient.Client, o } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, bool, uint16) error); ok { r1 = rf(client, opts, assetStatus, id) } else { @@ -112,6 +124,10 @@ func (_m *AssetManagerInterface) UpdateCollection(client *ethclient.Client, opts ret := _m.Called(client, opts, collectionId, tolerance, aggregationMethod, power, jobIds) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint16, uint32, uint32, int8, []uint16) (*types.Transaction, error)); ok { + return rf(client, opts, collectionId, tolerance, aggregationMethod, power, jobIds) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint16, uint32, uint32, int8, []uint16) *types.Transaction); ok { r0 = rf(client, opts, collectionId, tolerance, aggregationMethod, power, jobIds) } else { @@ -120,7 +136,6 @@ func (_m *AssetManagerInterface) UpdateCollection(client *ethclient.Client, opts } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint16, uint32, uint32, int8, []uint16) error); ok { r1 = rf(client, opts, collectionId, tolerance, aggregationMethod, power, jobIds) } else { @@ -135,6 +150,10 @@ func (_m *AssetManagerInterface) UpdateJob(client *ethclient.Client, opts *bind. ret := _m.Called(client, opts, jobId, weight, power, selectorType, selector, url) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint16, uint8, int8, uint8, string, string) (*types.Transaction, error)); ok { + return rf(client, opts, jobId, weight, power, selectorType, selector, url) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint16, uint8, int8, uint8, string, string) *types.Transaction); ok { r0 = rf(client, opts, jobId, weight, power, selectorType, selector, url) } else { @@ -143,7 +162,6 @@ func (_m *AssetManagerInterface) UpdateJob(client *ethclient.Client, opts *bind. } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint16, uint8, int8, uint8, string, string) error); ok { r1 = rf(client, opts, jobId, weight, power, selectorType, selector, url) } else { @@ -153,13 +171,12 @@ func (_m *AssetManagerInterface) UpdateJob(client *ethclient.Client, opts *bind. return r0, r1 } -type mockConstructorTestingTNewAssetManagerInterface interface { +// NewAssetManagerInterface creates a new instance of AssetManagerInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAssetManagerInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewAssetManagerInterface creates a new instance of AssetManagerInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewAssetManagerInterface(t mockConstructorTestingTNewAssetManagerInterface) *AssetManagerInterface { +}) *AssetManagerInterface { mock := &AssetManagerInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/block_manager_interface.go b/cmd/mocks/block_manager_interface.go index 37fc600a1..cc630d8ba 100644 --- a/cmd/mocks/block_manager_interface.go +++ b/cmd/mocks/block_manager_interface.go @@ -1,17 +1,12 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks import ( big "math/big" - bindings "razor/pkg/bindings" bind "github.com/ethereum/go-ethereum/accounts/abi/bind" - common "github.com/ethereum/go-ethereum/common" - - coretypes "razor/core/types" - ethclient "github.com/ethereum/go-ethereum/ethclient" mock "github.com/stretchr/testify/mock" @@ -29,6 +24,10 @@ func (_m *BlockManagerInterface) ClaimBlockReward(client *ethclient.Client, opts ret := _m.Called(client, opts) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts) (*types.Transaction, error)); ok { + return rf(client, opts) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts) *types.Transaction); ok { r0 = rf(client, opts) } else { @@ -37,7 +36,6 @@ func (_m *BlockManagerInterface) ClaimBlockReward(client *ethclient.Client, opts } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts) error); ok { r1 = rf(client, opts) } else { @@ -52,6 +50,10 @@ func (_m *BlockManagerInterface) DisputeBiggestStakeProposed(client *ethclient.C ret := _m.Called(client, opts, epoch, blockIndex, correctBiggestStakerId) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, uint32) (*types.Transaction, error)); ok { + return rf(client, opts, epoch, blockIndex, correctBiggestStakerId) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, uint32) *types.Transaction); ok { r0 = rf(client, opts, epoch, blockIndex, correctBiggestStakerId) } else { @@ -60,7 +62,6 @@ func (_m *BlockManagerInterface) DisputeBiggestStakeProposed(client *ethclient.C } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, uint32) error); ok { r1 = rf(client, opts, epoch, blockIndex, correctBiggestStakerId) } else { @@ -75,6 +76,10 @@ func (_m *BlockManagerInterface) DisputeCollectionIdShouldBeAbsent(client *ethcl ret := _m.Called(client, opts, epoch, blockIndex, id, positionOfCollectionInBlock) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, uint16, *big.Int) (*types.Transaction, error)); ok { + return rf(client, opts, epoch, blockIndex, id, positionOfCollectionInBlock) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, uint16, *big.Int) *types.Transaction); ok { r0 = rf(client, opts, epoch, blockIndex, id, positionOfCollectionInBlock) } else { @@ -83,7 +88,6 @@ func (_m *BlockManagerInterface) DisputeCollectionIdShouldBeAbsent(client *ethcl } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, uint16, *big.Int) error); ok { r1 = rf(client, opts, epoch, blockIndex, id, positionOfCollectionInBlock) } else { @@ -98,6 +102,10 @@ func (_m *BlockManagerInterface) DisputeCollectionIdShouldBePresent(client *ethc ret := _m.Called(client, opts, epoch, blockIndex, id) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, uint16) (*types.Transaction, error)); ok { + return rf(client, opts, epoch, blockIndex, id) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, uint16) *types.Transaction); ok { r0 = rf(client, opts, epoch, blockIndex, id) } else { @@ -106,7 +114,6 @@ func (_m *BlockManagerInterface) DisputeCollectionIdShouldBePresent(client *ethc } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, uint16) error); ok { r1 = rf(client, opts, epoch, blockIndex, id) } else { @@ -121,6 +128,10 @@ func (_m *BlockManagerInterface) DisputeOnOrderOfIds(client *ethclient.Client, o ret := _m.Called(client, opts, epoch, blockIndex, index0, index1) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, *big.Int, *big.Int) (*types.Transaction, error)); ok { + return rf(client, opts, epoch, blockIndex, index0, index1) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, *big.Int, *big.Int) *types.Transaction); ok { r0 = rf(client, opts, epoch, blockIndex, index0, index1) } else { @@ -129,7 +140,6 @@ func (_m *BlockManagerInterface) DisputeOnOrderOfIds(client *ethclient.Client, o } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, *big.Int, *big.Int) error); ok { r1 = rf(client, opts, epoch, blockIndex, index0, index1) } else { @@ -139,32 +149,15 @@ func (_m *BlockManagerInterface) DisputeOnOrderOfIds(client *ethclient.Client, o return r0, r1 } -// Disputes provides a mock function with given fields: client, opts, epoch, address -func (_m *BlockManagerInterface) Disputes(client *ethclient.Client, opts *bind.CallOpts, epoch uint32, address common.Address) (coretypes.DisputesStruct, error) { - ret := _m.Called(client, opts, epoch, address) - - var r0 coretypes.DisputesStruct - if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.CallOpts, uint32, common.Address) coretypes.DisputesStruct); ok { - r0 = rf(client, opts, epoch, address) - } else { - r0 = ret.Get(0).(coretypes.DisputesStruct) - } - - var r1 error - if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.CallOpts, uint32, common.Address) error); ok { - r1 = rf(client, opts, epoch, address) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - // FinalizeDispute provides a mock function with given fields: client, opts, epoch, blockIndex, positionOfCollectionInBlock func (_m *BlockManagerInterface) FinalizeDispute(client *ethclient.Client, opts *bind.TransactOpts, epoch uint32, blockIndex uint8, positionOfCollectionInBlock *big.Int) (*types.Transaction, error) { ret := _m.Called(client, opts, epoch, blockIndex, positionOfCollectionInBlock) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, *big.Int) (*types.Transaction, error)); ok { + return rf(client, opts, epoch, blockIndex, positionOfCollectionInBlock) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, *big.Int) *types.Transaction); ok { r0 = rf(client, opts, epoch, blockIndex, positionOfCollectionInBlock) } else { @@ -173,7 +166,6 @@ func (_m *BlockManagerInterface) FinalizeDispute(client *ethclient.Client, opts } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint8, *big.Int) error); ok { r1 = rf(client, opts, epoch, blockIndex, positionOfCollectionInBlock) } else { @@ -183,22 +175,25 @@ func (_m *BlockManagerInterface) FinalizeDispute(client *ethclient.Client, opts return r0, r1 } -// GiveSorted provides a mock function with given fields: blockManager, opts, epoch, leafId, sortedValues -func (_m *BlockManagerInterface) GiveSorted(blockManager *bindings.BlockManager, opts *bind.TransactOpts, epoch uint32, leafId uint16, sortedValues []*big.Int) (*types.Transaction, error) { - ret := _m.Called(blockManager, opts, epoch, leafId, sortedValues) +// GiveSorted provides a mock function with given fields: client, opts, epoch, leafId, sortedValues +func (_m *BlockManagerInterface) GiveSorted(client *ethclient.Client, opts *bind.TransactOpts, epoch uint32, leafId uint16, sortedValues []*big.Int) (*types.Transaction, error) { + ret := _m.Called(client, opts, epoch, leafId, sortedValues) var r0 *types.Transaction - if rf, ok := ret.Get(0).(func(*bindings.BlockManager, *bind.TransactOpts, uint32, uint16, []*big.Int) *types.Transaction); ok { - r0 = rf(blockManager, opts, epoch, leafId, sortedValues) + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint16, []*big.Int) (*types.Transaction, error)); ok { + return rf(client, opts, epoch, leafId, sortedValues) + } + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint16, []*big.Int) *types.Transaction); ok { + r0 = rf(client, opts, epoch, leafId, sortedValues) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*types.Transaction) } } - var r1 error - if rf, ok := ret.Get(1).(func(*bindings.BlockManager, *bind.TransactOpts, uint32, uint16, []*big.Int) error); ok { - r1 = rf(blockManager, opts, epoch, leafId, sortedValues) + if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, uint16, []*big.Int) error); ok { + r1 = rf(client, opts, epoch, leafId, sortedValues) } else { r1 = ret.Error(1) } @@ -211,6 +206,10 @@ func (_m *BlockManagerInterface) Propose(client *ethclient.Client, opts *bind.Tr ret := _m.Called(client, opts, epoch, ids, medians, iteration, biggestInfluencerId) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, []uint16, []*big.Int, *big.Int, uint32) (*types.Transaction, error)); ok { + return rf(client, opts, epoch, ids, medians, iteration, biggestInfluencerId) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, []uint16, []*big.Int, *big.Int, uint32) *types.Transaction); ok { r0 = rf(client, opts, epoch, ids, medians, iteration, biggestInfluencerId) } else { @@ -219,7 +218,6 @@ func (_m *BlockManagerInterface) Propose(client *ethclient.Client, opts *bind.Tr } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, []uint16, []*big.Int, *big.Int, uint32) error); ok { r1 = rf(client, opts, epoch, ids, medians, iteration, biggestInfluencerId) } else { @@ -229,22 +227,25 @@ func (_m *BlockManagerInterface) Propose(client *ethclient.Client, opts *bind.Tr return r0, r1 } -// ResetDispute provides a mock function with given fields: blockManager, opts, epoch -func (_m *BlockManagerInterface) ResetDispute(blockManager *bindings.BlockManager, opts *bind.TransactOpts, epoch uint32) (*types.Transaction, error) { - ret := _m.Called(blockManager, opts, epoch) +// ResetDispute provides a mock function with given fields: client, opts, epoch +func (_m *BlockManagerInterface) ResetDispute(client *ethclient.Client, opts *bind.TransactOpts, epoch uint32) (*types.Transaction, error) { + ret := _m.Called(client, opts, epoch) var r0 *types.Transaction - if rf, ok := ret.Get(0).(func(*bindings.BlockManager, *bind.TransactOpts, uint32) *types.Transaction); ok { - r0 = rf(blockManager, opts, epoch) + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) (*types.Transaction, error)); ok { + return rf(client, opts, epoch) + } + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) *types.Transaction); ok { + r0 = rf(client, opts, epoch) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*types.Transaction) } } - var r1 error - if rf, ok := ret.Get(1).(func(*bindings.BlockManager, *bind.TransactOpts, uint32) error); ok { - r1 = rf(blockManager, opts, epoch) + if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32) error); ok { + r1 = rf(client, opts, epoch) } else { r1 = ret.Error(1) } @@ -252,13 +253,12 @@ func (_m *BlockManagerInterface) ResetDispute(blockManager *bindings.BlockManage return r0, r1 } -type mockConstructorTestingTNewBlockManagerInterface interface { +// NewBlockManagerInterface creates a new instance of BlockManagerInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewBlockManagerInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewBlockManagerInterface creates a new instance of BlockManagerInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewBlockManagerInterface(t mockConstructorTestingTNewBlockManagerInterface) *BlockManagerInterface { +}) *BlockManagerInterface { mock := &BlockManagerInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/crypto_interface.go b/cmd/mocks/crypto_interface.go index 386334ac0..f842d91c3 100644 --- a/cmd/mocks/crypto_interface.go +++ b/cmd/mocks/crypto_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -18,6 +18,10 @@ func (_m *CryptoInterface) HexToECDSA(hexKey string) (*ecdsa.PrivateKey, error) ret := _m.Called(hexKey) var r0 *ecdsa.PrivateKey + var r1 error + if rf, ok := ret.Get(0).(func(string) (*ecdsa.PrivateKey, error)); ok { + return rf(hexKey) + } if rf, ok := ret.Get(0).(func(string) *ecdsa.PrivateKey); ok { r0 = rf(hexKey) } else { @@ -26,7 +30,6 @@ func (_m *CryptoInterface) HexToECDSA(hexKey string) (*ecdsa.PrivateKey, error) } } - var r1 error if rf, ok := ret.Get(1).(func(string) error); ok { r1 = rf(hexKey) } else { @@ -36,13 +39,12 @@ func (_m *CryptoInterface) HexToECDSA(hexKey string) (*ecdsa.PrivateKey, error) return r0, r1 } -type mockConstructorTestingTNewCryptoInterface interface { +// NewCryptoInterface creates a new instance of CryptoInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewCryptoInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewCryptoInterface creates a new instance of CryptoInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewCryptoInterface(t mockConstructorTestingTNewCryptoInterface) *CryptoInterface { +}) *CryptoInterface { mock := &CryptoInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/flag_set_interface.go b/cmd/mocks/flag_set_interface.go index e86159625..3fd59dad5 100644 --- a/cmd/mocks/flag_set_interface.go +++ b/cmd/mocks/flag_set_interface.go @@ -792,4 +792,4 @@ func NewFlagSetInterface(t interface { t.Cleanup(func() { mock.AssertExpectations(t) }) return mock -} \ No newline at end of file +} diff --git a/cmd/mocks/keystore_interface.go b/cmd/mocks/keystore_interface.go index b987385a5..8261cead9 100644 --- a/cmd/mocks/keystore_interface.go +++ b/cmd/mocks/keystore_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -36,13 +36,16 @@ func (_m *KeystoreInterface) ImportECDSA(path string, priv *ecdsa.PrivateKey, pa ret := _m.Called(path, priv, passphrase) var r0 accounts.Account + var r1 error + if rf, ok := ret.Get(0).(func(string, *ecdsa.PrivateKey, string) (accounts.Account, error)); ok { + return rf(path, priv, passphrase) + } if rf, ok := ret.Get(0).(func(string, *ecdsa.PrivateKey, string) accounts.Account); ok { r0 = rf(path, priv, passphrase) } else { r0 = ret.Get(0).(accounts.Account) } - var r1 error if rf, ok := ret.Get(1).(func(string, *ecdsa.PrivateKey, string) error); ok { r1 = rf(path, priv, passphrase) } else { @@ -52,13 +55,12 @@ func (_m *KeystoreInterface) ImportECDSA(path string, priv *ecdsa.PrivateKey, pa return r0, r1 } -type mockConstructorTestingTNewKeystoreInterface interface { +// NewKeystoreInterface creates a new instance of KeystoreInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewKeystoreInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewKeystoreInterface creates a new instance of KeystoreInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewKeystoreInterface(t mockConstructorTestingTNewKeystoreInterface) *KeystoreInterface { +}) *KeystoreInterface { mock := &KeystoreInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/os_interface.go b/cmd/mocks/os_interface.go index 84b7d0913..9a013ca02 100644 --- a/cmd/mocks/os_interface.go +++ b/cmd/mocks/os_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -14,13 +14,12 @@ func (_m *OSInterface) Exit(code int) { _m.Called(code) } -type mockConstructorTestingTNewOSInterface interface { +// NewOSInterface creates a new instance of OSInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewOSInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewOSInterface creates a new instance of OSInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewOSInterface(t mockConstructorTestingTNewOSInterface) *OSInterface { +}) *OSInterface { mock := &OSInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/stake_manager_interface.go b/cmd/mocks/stake_manager_interface.go index f0661906a..aaf25e318 100644 --- a/cmd/mocks/stake_manager_interface.go +++ b/cmd/mocks/stake_manager_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -9,8 +9,6 @@ import ( common "github.com/ethereum/go-ethereum/common" - coretypes "razor/core/types" - ethclient "github.com/ethereum/go-ethereum/ethclient" mock "github.com/stretchr/testify/mock" @@ -28,6 +26,10 @@ func (_m *StakeManagerInterface) ApproveUnstake(client *ethclient.Client, opts * ret := _m.Called(client, opts, stakerTokenAddress, amount) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, common.Address, *big.Int) (*types.Transaction, error)); ok { + return rf(client, opts, stakerTokenAddress, amount) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, common.Address, *big.Int) *types.Transaction); ok { r0 = rf(client, opts, stakerTokenAddress, amount) } else { @@ -36,7 +38,6 @@ func (_m *StakeManagerInterface) ApproveUnstake(client *ethclient.Client, opts * } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, common.Address, *big.Int) error); ok { r1 = rf(client, opts, stakerTokenAddress, amount) } else { @@ -51,6 +52,10 @@ func (_m *StakeManagerInterface) ClaimStakerReward(client *ethclient.Client, opt ret := _m.Called(client, opts) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts) (*types.Transaction, error)); ok { + return rf(client, opts) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts) *types.Transaction); ok { r0 = rf(client, opts) } else { @@ -59,7 +64,6 @@ func (_m *StakeManagerInterface) ClaimStakerReward(client *ethclient.Client, opt } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts) error); ok { r1 = rf(client, opts) } else { @@ -74,6 +78,10 @@ func (_m *StakeManagerInterface) Delegate(client *ethclient.Client, opts *bind.T ret := _m.Called(client, opts, stakerId, amount) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, *big.Int) (*types.Transaction, error)); ok { + return rf(client, opts, stakerId, amount) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, *big.Int) *types.Transaction); ok { r0 = rf(client, opts, stakerId, amount) } else { @@ -82,7 +90,6 @@ func (_m *StakeManagerInterface) Delegate(client *ethclient.Client, opts *bind.T } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, *big.Int) error); ok { r1 = rf(client, opts, stakerId, amount) } else { @@ -92,53 +99,15 @@ func (_m *StakeManagerInterface) Delegate(client *ethclient.Client, opts *bind.T return r0, r1 } -// GetBountyLock provides a mock function with given fields: client, opts, bountyId -func (_m *StakeManagerInterface) GetBountyLock(client *ethclient.Client, opts *bind.CallOpts, bountyId uint32) (coretypes.BountyLock, error) { - ret := _m.Called(client, opts, bountyId) - - var r0 coretypes.BountyLock - if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.CallOpts, uint32) coretypes.BountyLock); ok { - r0 = rf(client, opts, bountyId) - } else { - r0 = ret.Get(0).(coretypes.BountyLock) - } - - var r1 error - if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.CallOpts, uint32) error); ok { - r1 = rf(client, opts, bountyId) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// GetMaturity provides a mock function with given fields: client, opts, age -func (_m *StakeManagerInterface) GetMaturity(client *ethclient.Client, opts *bind.CallOpts, age uint32) (uint16, error) { - ret := _m.Called(client, opts, age) - - var r0 uint16 - if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.CallOpts, uint32) uint16); ok { - r0 = rf(client, opts, age) - } else { - r0 = ret.Get(0).(uint16) - } - - var r1 error - if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.CallOpts, uint32) error); ok { - r1 = rf(client, opts, age) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - // InitiateWithdraw provides a mock function with given fields: client, opts, stakerId func (_m *StakeManagerInterface) InitiateWithdraw(client *ethclient.Client, opts *bind.TransactOpts, stakerId uint32) (*types.Transaction, error) { ret := _m.Called(client, opts, stakerId) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) (*types.Transaction, error)); ok { + return rf(client, opts, stakerId) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) *types.Transaction); ok { r0 = rf(client, opts, stakerId) } else { @@ -147,7 +116,6 @@ func (_m *StakeManagerInterface) InitiateWithdraw(client *ethclient.Client, opts } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32) error); ok { r1 = rf(client, opts, stakerId) } else { @@ -162,6 +130,10 @@ func (_m *StakeManagerInterface) RedeemBounty(client *ethclient.Client, opts *bi ret := _m.Called(client, opts, bountyId) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) (*types.Transaction, error)); ok { + return rf(client, opts, bountyId) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) *types.Transaction); ok { r0 = rf(client, opts, bountyId) } else { @@ -170,7 +142,6 @@ func (_m *StakeManagerInterface) RedeemBounty(client *ethclient.Client, opts *bi } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32) error); ok { r1 = rf(client, opts, bountyId) } else { @@ -185,6 +156,10 @@ func (_m *StakeManagerInterface) ResetUnstakeLock(client *ethclient.Client, opts ret := _m.Called(client, opts, stakerId) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) (*types.Transaction, error)); ok { + return rf(client, opts, stakerId) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) *types.Transaction); ok { r0 = rf(client, opts, stakerId) } else { @@ -193,7 +168,6 @@ func (_m *StakeManagerInterface) ResetUnstakeLock(client *ethclient.Client, opts } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32) error); ok { r1 = rf(client, opts, stakerId) } else { @@ -208,6 +182,10 @@ func (_m *StakeManagerInterface) SetDelegationAcceptance(client *ethclient.Clien ret := _m.Called(client, opts, status) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, bool) (*types.Transaction, error)); ok { + return rf(client, opts, status) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, bool) *types.Transaction); ok { r0 = rf(client, opts, status) } else { @@ -216,7 +194,6 @@ func (_m *StakeManagerInterface) SetDelegationAcceptance(client *ethclient.Clien } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, bool) error); ok { r1 = rf(client, opts, status) } else { @@ -231,6 +208,10 @@ func (_m *StakeManagerInterface) Stake(client *ethclient.Client, txnOpts *bind.T ret := _m.Called(client, txnOpts, epoch, amount) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, *big.Int) (*types.Transaction, error)); ok { + return rf(client, txnOpts, epoch, amount) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, *big.Int) *types.Transaction); ok { r0 = rf(client, txnOpts, epoch, amount) } else { @@ -239,7 +220,6 @@ func (_m *StakeManagerInterface) Stake(client *ethclient.Client, txnOpts *bind.T } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, *big.Int) error); ok { r1 = rf(client, txnOpts, epoch, amount) } else { @@ -249,32 +229,15 @@ func (_m *StakeManagerInterface) Stake(client *ethclient.Client, txnOpts *bind.T return r0, r1 } -// StakerInfo provides a mock function with given fields: client, opts, stakerId -func (_m *StakeManagerInterface) StakerInfo(client *ethclient.Client, opts *bind.CallOpts, stakerId uint32) (coretypes.Staker, error) { - ret := _m.Called(client, opts, stakerId) - - var r0 coretypes.Staker - if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.CallOpts, uint32) coretypes.Staker); ok { - r0 = rf(client, opts, stakerId) - } else { - r0 = ret.Get(0).(coretypes.Staker) - } - - var r1 error - if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.CallOpts, uint32) error); ok { - r1 = rf(client, opts, stakerId) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - // UnlockWithdraw provides a mock function with given fields: client, opts, stakerId func (_m *StakeManagerInterface) UnlockWithdraw(client *ethclient.Client, opts *bind.TransactOpts, stakerId uint32) (*types.Transaction, error) { ret := _m.Called(client, opts, stakerId) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) (*types.Transaction, error)); ok { + return rf(client, opts, stakerId) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) *types.Transaction); ok { r0 = rf(client, opts, stakerId) } else { @@ -283,7 +246,6 @@ func (_m *StakeManagerInterface) UnlockWithdraw(client *ethclient.Client, opts * } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32) error); ok { r1 = rf(client, opts, stakerId) } else { @@ -298,6 +260,10 @@ func (_m *StakeManagerInterface) Unstake(client *ethclient.Client, opts *bind.Tr ret := _m.Called(client, opts, stakerId, sAmount) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, *big.Int) (*types.Transaction, error)); ok { + return rf(client, opts, stakerId, sAmount) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, *big.Int) *types.Transaction); ok { r0 = rf(client, opts, stakerId, sAmount) } else { @@ -306,7 +272,6 @@ func (_m *StakeManagerInterface) Unstake(client *ethclient.Client, opts *bind.Tr } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, *big.Int) error); ok { r1 = rf(client, opts, stakerId, sAmount) } else { @@ -321,6 +286,10 @@ func (_m *StakeManagerInterface) UpdateCommission(client *ethclient.Client, opts ret := _m.Called(client, opts, commission) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint8) (*types.Transaction, error)); ok { + return rf(client, opts, commission) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint8) *types.Transaction); ok { r0 = rf(client, opts, commission) } else { @@ -329,7 +298,6 @@ func (_m *StakeManagerInterface) UpdateCommission(client *ethclient.Client, opts } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint8) error); ok { r1 = rf(client, opts, commission) } else { @@ -339,13 +307,12 @@ func (_m *StakeManagerInterface) UpdateCommission(client *ethclient.Client, opts return r0, r1 } -type mockConstructorTestingTNewStakeManagerInterface interface { +// NewStakeManagerInterface creates a new instance of StakeManagerInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStakeManagerInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewStakeManagerInterface creates a new instance of StakeManagerInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewStakeManagerInterface(t mockConstructorTestingTNewStakeManagerInterface) *StakeManagerInterface { +}) *StakeManagerInterface { mock := &StakeManagerInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/string_interface.go b/cmd/mocks/string_interface.go index de733d7aa..2eb16556e 100644 --- a/cmd/mocks/string_interface.go +++ b/cmd/mocks/string_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -14,13 +14,16 @@ func (_m *StringInterface) ParseBool(str string) (bool, error) { ret := _m.Called(str) var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(string) (bool, error)); ok { + return rf(str) + } if rf, ok := ret.Get(0).(func(string) bool); ok { r0 = rf(str) } else { r0 = ret.Get(0).(bool) } - var r1 error if rf, ok := ret.Get(1).(func(string) error); ok { r1 = rf(str) } else { @@ -30,13 +33,12 @@ func (_m *StringInterface) ParseBool(str string) (bool, error) { return r0, r1 } -type mockConstructorTestingTNewStringInterface interface { +// NewStringInterface creates a new instance of StringInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStringInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewStringInterface creates a new instance of StringInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewStringInterface(t mockConstructorTestingTNewStringInterface) *StringInterface { +}) *StringInterface { mock := &StringInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/time_interface.go b/cmd/mocks/time_interface.go index 7e3a8ca96..d1b6858af 100644 --- a/cmd/mocks/time_interface.go +++ b/cmd/mocks/time_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -18,13 +18,12 @@ func (_m *TimeInterface) Sleep(duration time.Duration) { _m.Called(duration) } -type mockConstructorTestingTNewTimeInterface interface { +// NewTimeInterface creates a new instance of TimeInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTimeInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewTimeInterface creates a new instance of TimeInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewTimeInterface(t mockConstructorTestingTNewTimeInterface) *TimeInterface { +}) *TimeInterface { mock := &TimeInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/token_manager_interface.go b/cmd/mocks/token_manager_interface.go index c5f946869..7bbc2ba68 100644 --- a/cmd/mocks/token_manager_interface.go +++ b/cmd/mocks/token_manager_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -21,34 +21,15 @@ type TokenManagerInterface struct { mock.Mock } -// Allowance provides a mock function with given fields: client, opts, owner, spender -func (_m *TokenManagerInterface) Allowance(client *ethclient.Client, opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { - ret := _m.Called(client, opts, owner, spender) - - var r0 *big.Int - if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.CallOpts, common.Address, common.Address) *big.Int); ok { - r0 = rf(client, opts, owner, spender) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*big.Int) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.CallOpts, common.Address, common.Address) error); ok { - r1 = rf(client, opts, owner, spender) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - // Approve provides a mock function with given fields: client, opts, spender, amount func (_m *TokenManagerInterface) Approve(client *ethclient.Client, opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { ret := _m.Called(client, opts, spender, amount) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, common.Address, *big.Int) (*types.Transaction, error)); ok { + return rf(client, opts, spender, amount) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, common.Address, *big.Int) *types.Transaction); ok { r0 = rf(client, opts, spender, amount) } else { @@ -57,7 +38,6 @@ func (_m *TokenManagerInterface) Approve(client *ethclient.Client, opts *bind.Tr } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, common.Address, *big.Int) error); ok { r1 = rf(client, opts, spender, amount) } else { @@ -72,6 +52,10 @@ func (_m *TokenManagerInterface) Transfer(client *ethclient.Client, opts *bind.T ret := _m.Called(client, opts, recipient, amount) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, common.Address, *big.Int) (*types.Transaction, error)); ok { + return rf(client, opts, recipient, amount) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, common.Address, *big.Int) *types.Transaction); ok { r0 = rf(client, opts, recipient, amount) } else { @@ -80,7 +64,6 @@ func (_m *TokenManagerInterface) Transfer(client *ethclient.Client, opts *bind.T } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, common.Address, *big.Int) error); ok { r1 = rf(client, opts, recipient, amount) } else { @@ -90,13 +73,12 @@ func (_m *TokenManagerInterface) Transfer(client *ethclient.Client, opts *bind.T return r0, r1 } -type mockConstructorTestingTNewTokenManagerInterface interface { +// NewTokenManagerInterface creates a new instance of TokenManagerInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTokenManagerInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewTokenManagerInterface creates a new instance of TokenManagerInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewTokenManagerInterface(t mockConstructorTestingTNewTokenManagerInterface) *TokenManagerInterface { +}) *TokenManagerInterface { mock := &TokenManagerInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/transaction_interface.go b/cmd/mocks/transaction_interface.go index 9255cd7b8..c3bd72ea6 100644 --- a/cmd/mocks/transaction_interface.go +++ b/cmd/mocks/transaction_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -30,13 +30,12 @@ func (_m *TransactionInterface) Hash(txn *types.Transaction) common.Hash { return r0 } -type mockConstructorTestingTNewTransactionInterface interface { +// NewTransactionInterface creates a new instance of TransactionInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTransactionInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewTransactionInterface creates a new instance of TransactionInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewTransactionInterface(t mockConstructorTestingTNewTransactionInterface) *TransactionInterface { +}) *TransactionInterface { mock := &TransactionInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/utils_cmd_interface.go b/cmd/mocks/utils_cmd_interface.go index b957be0e5..7a7317ec3 100644 --- a/cmd/mocks/utils_cmd_interface.go +++ b/cmd/mocks/utils_cmd_interface.go @@ -4,6 +4,8 @@ package mocks import ( big "math/big" + "razor/block" + RPC "razor/rpc" accounts "github.com/ethereum/go-ethereum/accounts" @@ -15,12 +17,8 @@ import ( common "github.com/ethereum/go-ethereum/common" - context "context" - coretypes "github.com/ethereum/go-ethereum/core/types" - ethclient "github.com/ethereum/go-ethereum/ethclient" - mock "github.com/stretchr/testify/mock" pflag "github.com/spf13/pflag" @@ -33,25 +31,25 @@ type UtilsCmdInterface struct { mock.Mock } -// Approve provides a mock function with given fields: txnArgs -func (_m *UtilsCmdInterface) Approve(txnArgs types.TransactionOptions) (common.Hash, error) { - ret := _m.Called(txnArgs) +// Approve provides a mock function with given fields: rpcParameters, txnArgs +func (_m *UtilsCmdInterface) Approve(rpcParameters RPC.RPCParameters, txnArgs types.TransactionOptions) (common.Hash, error) { + ret := _m.Called(rpcParameters, txnArgs) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(types.TransactionOptions) (common.Hash, error)); ok { - return rf(txnArgs) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions) (common.Hash, error)); ok { + return rf(rpcParameters, txnArgs) } - if rf, ok := ret.Get(0).(func(types.TransactionOptions) common.Hash); ok { - r0 = rf(txnArgs) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions) common.Hash); ok { + r0 = rf(rpcParameters, txnArgs) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(types.TransactionOptions) error); ok { - r1 = rf(txnArgs) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.TransactionOptions) error); ok { + r1 = rf(rpcParameters, txnArgs) } else { r1 = ret.Error(1) } @@ -59,25 +57,25 @@ func (_m *UtilsCmdInterface) Approve(txnArgs types.TransactionOptions) (common.H return r0, r1 } -// ApproveUnstake provides a mock function with given fields: client, stakerTokenAddress, txnArgs -func (_m *UtilsCmdInterface) ApproveUnstake(client *ethclient.Client, stakerTokenAddress common.Address, txnArgs types.TransactionOptions) (common.Hash, error) { - ret := _m.Called(client, stakerTokenAddress, txnArgs) +// ApproveUnstake provides a mock function with given fields: rpcParameters, stakerTokenAddress, txnArgs +func (_m *UtilsCmdInterface) ApproveUnstake(rpcParameters RPC.RPCParameters, stakerTokenAddress common.Address, txnArgs types.TransactionOptions) (common.Hash, error) { + ret := _m.Called(rpcParameters, stakerTokenAddress, txnArgs) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address, types.TransactionOptions) (common.Hash, error)); ok { - return rf(client, stakerTokenAddress, txnArgs) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, common.Address, types.TransactionOptions) (common.Hash, error)); ok { + return rf(rpcParameters, stakerTokenAddress, txnArgs) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address, types.TransactionOptions) common.Hash); ok { - r0 = rf(client, stakerTokenAddress, txnArgs) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, common.Address, types.TransactionOptions) common.Hash); ok { + r0 = rf(rpcParameters, stakerTokenAddress, txnArgs) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, common.Address, types.TransactionOptions) error); ok { - r1 = rf(client, stakerTokenAddress, txnArgs) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, common.Address, types.TransactionOptions) error); ok { + r1 = rf(rpcParameters, stakerTokenAddress, txnArgs) } else { r1 = ret.Error(1) } @@ -111,25 +109,25 @@ func (_m *UtilsCmdInterface) AssignAmountInWei(flagSet *pflag.FlagSet) (*big.Int return r0, r1 } -// BatchGetStakeSnapshotCalls provides a mock function with given fields: client, epoch, numberOfStakers -func (_m *UtilsCmdInterface) BatchGetStakeSnapshotCalls(client *ethclient.Client, epoch uint32, numberOfStakers uint32) ([]*big.Int, error) { - ret := _m.Called(client, epoch, numberOfStakers) +// BatchGetStakeSnapshotCalls provides a mock function with given fields: rpcParameters, epoch, numberOfStakers +func (_m *UtilsCmdInterface) BatchGetStakeSnapshotCalls(rpcParameters RPC.RPCParameters, epoch uint32, numberOfStakers uint32) ([]*big.Int, error) { + ret := _m.Called(rpcParameters, epoch, numberOfStakers) var r0 []*big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32) ([]*big.Int, error)); ok { - return rf(client, epoch, numberOfStakers) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint32, uint32) ([]*big.Int, error)); ok { + return rf(rpcParameters, epoch, numberOfStakers) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32) []*big.Int); ok { - r0 = rf(client, epoch, numberOfStakers) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint32, uint32) []*big.Int); ok { + r0 = rf(rpcParameters, epoch, numberOfStakers) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, uint32) error); ok { - r1 = rf(client, epoch, numberOfStakers) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, uint32, uint32) error); ok { + r1 = rf(rpcParameters, epoch, numberOfStakers) } else { r1 = ret.Error(1) } @@ -172,49 +170,25 @@ func (_m *UtilsCmdInterface) CalculateSecret(account types.Account, epoch uint32 return r0, r1, r2 } -// CheckCurrentStatus provides a mock function with given fields: client, collectionId -func (_m *UtilsCmdInterface) CheckCurrentStatus(client *ethclient.Client, collectionId uint16) (bool, error) { - ret := _m.Called(client, collectionId) - - var r0 bool - var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (bool, error)); ok { - return rf(client, collectionId) - } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) bool); ok { - r0 = rf(client, collectionId) - } else { - r0 = ret.Get(0).(bool) - } - - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { - r1 = rf(client, collectionId) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// CheckDisputeForIds provides a mock function with given fields: client, transactionOpts, epoch, blockIndex, idsInProposedBlock, revealedCollectionIds -func (_m *UtilsCmdInterface) CheckDisputeForIds(client *ethclient.Client, transactionOpts types.TransactionOptions, epoch uint32, blockIndex uint8, idsInProposedBlock []uint16, revealedCollectionIds []uint16) (*coretypes.Transaction, error) { - ret := _m.Called(client, transactionOpts, epoch, blockIndex, idsInProposedBlock, revealedCollectionIds) +// CheckDisputeForIds provides a mock function with given fields: rpcParameters, transactionOpts, epoch, blockIndex, idsInProposedBlock, revealedCollectionIds +func (_m *UtilsCmdInterface) CheckDisputeForIds(rpcParameters RPC.RPCParameters, transactionOpts types.TransactionOptions, epoch uint32, blockIndex uint8, idsInProposedBlock []uint16, revealedCollectionIds []uint16) (*coretypes.Transaction, error) { + ret := _m.Called(rpcParameters, transactionOpts, epoch, blockIndex, idsInProposedBlock, revealedCollectionIds) var r0 *coretypes.Transaction var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.TransactionOptions, uint32, uint8, []uint16, []uint16) (*coretypes.Transaction, error)); ok { - return rf(client, transactionOpts, epoch, blockIndex, idsInProposedBlock, revealedCollectionIds) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions, uint32, uint8, []uint16, []uint16) (*coretypes.Transaction, error)); ok { + return rf(rpcParameters, transactionOpts, epoch, blockIndex, idsInProposedBlock, revealedCollectionIds) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.TransactionOptions, uint32, uint8, []uint16, []uint16) *coretypes.Transaction); ok { - r0 = rf(client, transactionOpts, epoch, blockIndex, idsInProposedBlock, revealedCollectionIds) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions, uint32, uint8, []uint16, []uint16) *coretypes.Transaction); ok { + r0 = rf(rpcParameters, transactionOpts, epoch, blockIndex, idsInProposedBlock, revealedCollectionIds) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*coretypes.Transaction) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.TransactionOptions, uint32, uint8, []uint16, []uint16) error); ok { - r1 = rf(client, transactionOpts, epoch, blockIndex, idsInProposedBlock, revealedCollectionIds) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.TransactionOptions, uint32, uint8, []uint16, []uint16) error); ok { + r1 = rf(rpcParameters, transactionOpts, epoch, blockIndex, idsInProposedBlock, revealedCollectionIds) } else { r1 = ret.Error(1) } @@ -222,13 +196,13 @@ func (_m *UtilsCmdInterface) CheckDisputeForIds(client *ethclient.Client, transa return r0, r1 } -// CheckForLastCommitted provides a mock function with given fields: client, staker, epoch -func (_m *UtilsCmdInterface) CheckForLastCommitted(client *ethclient.Client, staker bindings.StructsStaker, epoch uint32) error { - ret := _m.Called(client, staker, epoch) +// CheckForLastCommitted provides a mock function with given fields: rpcParameters, staker, epoch +func (_m *UtilsCmdInterface) CheckForLastCommitted(rpcParameters RPC.RPCParameters, staker bindings.StructsStaker, epoch uint32) error { + ret := _m.Called(rpcParameters, staker, epoch) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, bindings.StructsStaker, uint32) error); ok { - r0 = rf(client, staker, epoch) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, bindings.StructsStaker, uint32) error); ok { + r0 = rf(rpcParameters, staker, epoch) } else { r0 = ret.Error(0) } @@ -236,30 +210,30 @@ func (_m *UtilsCmdInterface) CheckForLastCommitted(client *ethclient.Client, sta return r0 } -// CheckToDoResetDispute provides a mock function with given fields: client, blockManager, txnOpts, epoch, sortedValues -func (_m *UtilsCmdInterface) CheckToDoResetDispute(client *ethclient.Client, blockManager *bindings.BlockManager, txnOpts *bind.TransactOpts, epoch uint32, sortedValues []*big.Int) { - _m.Called(client, blockManager, txnOpts, epoch, sortedValues) +// CheckToDoResetDispute provides a mock function with given fields: rpcParameters, txnOpts, epoch, sortedValues +func (_m *UtilsCmdInterface) CheckToDoResetDispute(rpcParameters RPC.RPCParameters, txnOpts *bind.TransactOpts, epoch uint32, sortedValues []*big.Int) { + _m.Called(rpcParameters, txnOpts, epoch, sortedValues) } -// ClaimBlockReward provides a mock function with given fields: options -func (_m *UtilsCmdInterface) ClaimBlockReward(options types.TransactionOptions) (common.Hash, error) { - ret := _m.Called(options) +// ClaimBlockReward provides a mock function with given fields: rpcParameters, options +func (_m *UtilsCmdInterface) ClaimBlockReward(rpcParameters RPC.RPCParameters, options types.TransactionOptions) (common.Hash, error) { + ret := _m.Called(rpcParameters, options) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(types.TransactionOptions) (common.Hash, error)); ok { - return rf(options) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions) (common.Hash, error)); ok { + return rf(rpcParameters, options) } - if rf, ok := ret.Get(0).(func(types.TransactionOptions) common.Hash); ok { - r0 = rf(options) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions) common.Hash); ok { + r0 = rf(rpcParameters, options) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(types.TransactionOptions) error); ok { - r1 = rf(options) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.TransactionOptions) error); ok { + r1 = rf(rpcParameters, options) } else { r1 = ret.Error(1) } @@ -267,25 +241,25 @@ func (_m *UtilsCmdInterface) ClaimBlockReward(options types.TransactionOptions) return r0, r1 } -// ClaimBounty provides a mock function with given fields: config, client, redeemBountyInput -func (_m *UtilsCmdInterface) ClaimBounty(config types.Configurations, client *ethclient.Client, redeemBountyInput types.RedeemBountyInput) (common.Hash, error) { - ret := _m.Called(config, client, redeemBountyInput) +// ClaimBounty provides a mock function with given fields: rpcParameters, config, redeemBountyInput +func (_m *UtilsCmdInterface) ClaimBounty(rpcParameters RPC.RPCParameters, config types.Configurations, redeemBountyInput types.RedeemBountyInput) (common.Hash, error) { + ret := _m.Called(rpcParameters, config, redeemBountyInput) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(types.Configurations, *ethclient.Client, types.RedeemBountyInput) (common.Hash, error)); ok { - return rf(config, client, redeemBountyInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.RedeemBountyInput) (common.Hash, error)); ok { + return rf(rpcParameters, config, redeemBountyInput) } - if rf, ok := ret.Get(0).(func(types.Configurations, *ethclient.Client, types.RedeemBountyInput) common.Hash); ok { - r0 = rf(config, client, redeemBountyInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.RedeemBountyInput) common.Hash); ok { + r0 = rf(rpcParameters, config, redeemBountyInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(types.Configurations, *ethclient.Client, types.RedeemBountyInput) error); ok { - r1 = rf(config, client, redeemBountyInput) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.RedeemBountyInput) error); ok { + r1 = rf(rpcParameters, config, redeemBountyInput) } else { r1 = ret.Error(1) } @@ -298,25 +272,25 @@ func (_m *UtilsCmdInterface) ClaimCommission(flagSet *pflag.FlagSet) { _m.Called(flagSet) } -// Commit provides a mock function with given fields: client, config, account, epoch, latestHeader, seed, values -func (_m *UtilsCmdInterface) Commit(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, latestHeader *coretypes.Header, seed []byte, values []*big.Int) (common.Hash, error) { - ret := _m.Called(client, config, account, epoch, latestHeader, seed, values) +// Commit provides a mock function with given fields: rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitment +func (_m *UtilsCmdInterface) Commit(rpcParameters RPC.RPCParameters, config types.Configurations, account types.Account, epoch uint32, latestHeader *coretypes.Header, stateBuffer uint64, commitment [32]byte) (common.Hash, error) { + ret := _m.Called(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitment) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.Account, uint32, *coretypes.Header, []byte, []*big.Int) (common.Hash, error)); ok { - return rf(client, config, account, epoch, latestHeader, seed, values) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.Account, uint32, *coretypes.Header, uint64, [32]byte) (common.Hash, error)); ok { + return rf(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitment) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.Account, uint32, *coretypes.Header, []byte, []*big.Int) common.Hash); ok { - r0 = rf(client, config, account, epoch, latestHeader, seed, values) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.Account, uint32, *coretypes.Header, uint64, [32]byte) common.Hash); ok { + r0 = rf(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitment) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Configurations, types.Account, uint32, *coretypes.Header, []byte, []*big.Int) error); ok { - r1 = rf(client, config, account, epoch, latestHeader, seed, values) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.Account, uint32, *coretypes.Header, uint64, [32]byte) error); ok { + r1 = rf(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitment) } else { r1 = ret.Error(1) } @@ -353,25 +327,25 @@ func (_m *UtilsCmdInterface) Create(password string) (accounts.Account, error) { return r0, r1 } -// CreateCollection provides a mock function with given fields: client, config, collectionInput -func (_m *UtilsCmdInterface) CreateCollection(client *ethclient.Client, config types.Configurations, collectionInput types.CreateCollectionInput) (common.Hash, error) { - ret := _m.Called(client, config, collectionInput) +// CreateCollection provides a mock function with given fields: rpcParameters, config, collectionInput +func (_m *UtilsCmdInterface) CreateCollection(rpcParameters RPC.RPCParameters, config types.Configurations, collectionInput types.CreateCollectionInput) (common.Hash, error) { + ret := _m.Called(rpcParameters, config, collectionInput) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.CreateCollectionInput) (common.Hash, error)); ok { - return rf(client, config, collectionInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.CreateCollectionInput) (common.Hash, error)); ok { + return rf(rpcParameters, config, collectionInput) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.CreateCollectionInput) common.Hash); ok { - r0 = rf(client, config, collectionInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.CreateCollectionInput) common.Hash); ok { + r0 = rf(rpcParameters, config, collectionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Configurations, types.CreateCollectionInput) error); ok { - r1 = rf(client, config, collectionInput) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.CreateCollectionInput) error); ok { + r1 = rf(rpcParameters, config, collectionInput) } else { r1 = ret.Error(1) } @@ -379,25 +353,25 @@ func (_m *UtilsCmdInterface) CreateCollection(client *ethclient.Client, config t return r0, r1 } -// CreateJob provides a mock function with given fields: client, config, jobInput -func (_m *UtilsCmdInterface) CreateJob(client *ethclient.Client, config types.Configurations, jobInput types.CreateJobInput) (common.Hash, error) { - ret := _m.Called(client, config, jobInput) +// CreateJob provides a mock function with given fields: rpcParameter, config, jobInput +func (_m *UtilsCmdInterface) CreateJob(rpcParameter RPC.RPCParameters, config types.Configurations, jobInput types.CreateJobInput) (common.Hash, error) { + ret := _m.Called(rpcParameter, config, jobInput) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.CreateJobInput) (common.Hash, error)); ok { - return rf(client, config, jobInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.CreateJobInput) (common.Hash, error)); ok { + return rf(rpcParameter, config, jobInput) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.CreateJobInput) common.Hash); ok { - r0 = rf(client, config, jobInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.CreateJobInput) common.Hash); ok { + r0 = rf(rpcParameter, config, jobInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Configurations, types.CreateJobInput) error); ok { - r1 = rf(client, config, jobInput) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.CreateJobInput) error); ok { + r1 = rf(rpcParameter, config, jobInput) } else { r1 = ret.Error(1) } @@ -405,25 +379,25 @@ func (_m *UtilsCmdInterface) CreateJob(client *ethclient.Client, config types.Co return r0, r1 } -// Delegate provides a mock function with given fields: txnArgs, stakerId -func (_m *UtilsCmdInterface) Delegate(txnArgs types.TransactionOptions, stakerId uint32) (common.Hash, error) { - ret := _m.Called(txnArgs, stakerId) +// Delegate provides a mock function with given fields: rpcParameters, txnArgs, stakerId +func (_m *UtilsCmdInterface) Delegate(rpcParameters RPC.RPCParameters, txnArgs types.TransactionOptions, stakerId uint32) (common.Hash, error) { + ret := _m.Called(rpcParameters, txnArgs, stakerId) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(types.TransactionOptions, uint32) (common.Hash, error)); ok { - return rf(txnArgs, stakerId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions, uint32) (common.Hash, error)); ok { + return rf(rpcParameters, txnArgs, stakerId) } - if rf, ok := ret.Get(0).(func(types.TransactionOptions, uint32) common.Hash); ok { - r0 = rf(txnArgs, stakerId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions, uint32) common.Hash); ok { + r0 = rf(rpcParameters, txnArgs, stakerId) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(types.TransactionOptions, uint32) error); ok { - r1 = rf(txnArgs, stakerId) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.TransactionOptions, uint32) error); ok { + r1 = rf(rpcParameters, txnArgs, stakerId) } else { r1 = ret.Error(1) } @@ -431,13 +405,13 @@ func (_m *UtilsCmdInterface) Delegate(txnArgs types.TransactionOptions, stakerId return r0, r1 } -// Dispute provides a mock function with given fields: client, config, account, epoch, blockIndex, proposedBlock, leafId, sortedValues -func (_m *UtilsCmdInterface) Dispute(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, blockIndex uint8, proposedBlock bindings.StructsBlock, leafId uint16, sortedValues []*big.Int) error { - ret := _m.Called(client, config, account, epoch, blockIndex, proposedBlock, leafId, sortedValues) +// Dispute provides a mock function with given fields: rpcParameters, config, account, epoch, blockIndex, proposedBlock, leafId, sortedValues +func (_m *UtilsCmdInterface) Dispute(rpcParameters RPC.RPCParameters, config types.Configurations, account types.Account, epoch uint32, blockIndex uint8, proposedBlock bindings.StructsBlock, leafId uint16, sortedValues []*big.Int) error { + ret := _m.Called(rpcParameters, config, account, epoch, blockIndex, proposedBlock, leafId, sortedValues) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.Account, uint32, uint8, bindings.StructsBlock, uint16, []*big.Int) error); ok { - r0 = rf(client, config, account, epoch, blockIndex, proposedBlock, leafId, sortedValues) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.Account, uint32, uint8, bindings.StructsBlock, uint16, []*big.Int) error); ok { + r0 = rf(rpcParameters, config, account, epoch, blockIndex, proposedBlock, leafId, sortedValues) } else { r0 = ret.Error(0) } @@ -490,6 +464,11 @@ func (_m *UtilsCmdInterface) ExecuteImport(flagSet *pflag.FlagSet) { _m.Called(flagSet) } +// ExecuteImportEndpoints provides a mock function with given fields: +func (_m *UtilsCmdInterface) ExecuteImportEndpoints() { + _m.Called() +} + // ExecuteInitiateWithdraw provides a mock function with given fields: flagSet func (_m *UtilsCmdInterface) ExecuteInitiateWithdraw(flagSet *pflag.FlagSet) { _m.Called(flagSet) @@ -574,56 +553,32 @@ func (_m *UtilsCmdInterface) GenerateTreeRevealData(merkleTree [][][]byte, commi return r0 } -// GetAlternateProvider provides a mock function with given fields: -func (_m *UtilsCmdInterface) GetAlternateProvider() (string, error) { - ret := _m.Called() - - var r0 string - var r1 error - if rf, ok := ret.Get(0).(func() (string, error)); ok { - return rf() - } - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() - } else { - r0 = ret.Get(0).(string) - } - - if rf, ok := ret.Get(1).(func() error); ok { - r1 = rf() - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// GetBiggestStakeAndId provides a mock function with given fields: client, epoch -func (_m *UtilsCmdInterface) GetBiggestStakeAndId(client *ethclient.Client, epoch uint32) (*big.Int, uint32, error) { - ret := _m.Called(client, epoch) +// GetBiggestStakeAndId provides a mock function with given fields: rpcParameters, epoch +func (_m *UtilsCmdInterface) GetBiggestStakeAndId(rpcParameters RPC.RPCParameters, epoch uint32) (*big.Int, uint32, error) { + ret := _m.Called(rpcParameters, epoch) var r0 *big.Int var r1 uint32 var r2 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (*big.Int, uint32, error)); ok { - return rf(client, epoch) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint32) (*big.Int, uint32, error)); ok { + return rf(rpcParameters, epoch) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) *big.Int); ok { - r0 = rf(client, epoch) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint32) *big.Int); ok { + r0 = rf(rpcParameters, epoch) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) uint32); ok { - r1 = rf(client, epoch) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, uint32) uint32); ok { + r1 = rf(rpcParameters, epoch) } else { r1 = ret.Get(1).(uint32) } - if rf, ok := ret.Get(2).(func(*ethclient.Client, uint32) error); ok { - r2 = rf(client, epoch) + if rf, ok := ret.Get(2).(func(RPC.RPCParameters, uint32) error); ok { + r2 = rf(rpcParameters, epoch) } else { r2 = ret.Error(2) } @@ -631,23 +586,23 @@ func (_m *UtilsCmdInterface) GetBiggestStakeAndId(client *ethclient.Client, epoc return r0, r1, r2 } -// GetBountyIdFromEvents provides a mock function with given fields: client, blockNumber, bountyHunter -func (_m *UtilsCmdInterface) GetBountyIdFromEvents(client *ethclient.Client, blockNumber *big.Int, bountyHunter string) (uint32, error) { - ret := _m.Called(client, blockNumber, bountyHunter) +// GetBountyIdFromEvents provides a mock function with given fields: rpcParameters, blockNumber, bountyHunter +func (_m *UtilsCmdInterface) GetBountyIdFromEvents(rpcParameters RPC.RPCParameters, blockNumber *big.Int, bountyHunter string) (uint32, error) { + ret := _m.Called(rpcParameters, blockNumber, bountyHunter) var r0 uint32 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, *big.Int, string) (uint32, error)); ok { - return rf(client, blockNumber, bountyHunter) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *big.Int, string) (uint32, error)); ok { + return rf(rpcParameters, blockNumber, bountyHunter) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, *big.Int, string) uint32); ok { - r0 = rf(client, blockNumber, bountyHunter) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *big.Int, string) uint32); ok { + r0 = rf(rpcParameters, blockNumber, bountyHunter) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, *big.Int, string) error); ok { - r1 = rf(client, blockNumber, bountyHunter) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, *big.Int, string) error); ok { + r1 = rf(rpcParameters, blockNumber, bountyHunter) } else { r1 = ret.Error(1) } @@ -679,13 +634,13 @@ func (_m *UtilsCmdInterface) GetBufferPercent() (int32, error) { return r0, r1 } -// GetCollectionIdPositionInBlock provides a mock function with given fields: client, leafId, proposedBlock -func (_m *UtilsCmdInterface) GetCollectionIdPositionInBlock(client *ethclient.Client, leafId uint16, proposedBlock bindings.StructsBlock) *big.Int { - ret := _m.Called(client, leafId, proposedBlock) +// GetCollectionIdPositionInBlock provides a mock function with given fields: rpcParameters, leafId, proposedBlock +func (_m *UtilsCmdInterface) GetCollectionIdPositionInBlock(rpcParameters RPC.RPCParameters, leafId uint16, proposedBlock bindings.StructsBlock) *big.Int { + ret := _m.Called(rpcParameters, leafId, proposedBlock) var r0 *big.Int - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16, bindings.StructsBlock) *big.Int); ok { - r0 = rf(client, leafId, proposedBlock) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint16, bindings.StructsBlock) *big.Int); ok { + r0 = rf(rpcParameters, leafId, proposedBlock) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) @@ -695,13 +650,13 @@ func (_m *UtilsCmdInterface) GetCollectionIdPositionInBlock(client *ethclient.Cl return r0 } -// GetCollectionList provides a mock function with given fields: client -func (_m *UtilsCmdInterface) GetCollectionList(client *ethclient.Client) error { - ret := _m.Called(client) +// GetCollectionList provides a mock function with given fields: rpcParameters +func (_m *UtilsCmdInterface) GetCollectionList(rpcParameters RPC.RPCParameters) error { + ret := _m.Called(rpcParameters) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) error); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters) error); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Error(0) } @@ -733,30 +688,30 @@ func (_m *UtilsCmdInterface) GetConfigData() (types.Configurations, error) { return r0, r1 } -// GetEpochAndState provides a mock function with given fields: client -func (_m *UtilsCmdInterface) GetEpochAndState(client *ethclient.Client) (uint32, int64, error) { - ret := _m.Called(client) +// GetEpochAndState provides a mock function with given fields: rpcParameter +func (_m *UtilsCmdInterface) GetEpochAndState(rpcParameter RPC.RPCParameters) (uint32, int64, error) { + ret := _m.Called(rpcParameter) var r0 uint32 var r1 int64 var r2 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint32, int64, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters) (uint32, int64, error)); ok { + return rf(rpcParameter) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) uint32); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters) uint32); ok { + r0 = rf(rpcParameter) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) int64); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters) int64); ok { + r1 = rf(rpcParameter) } else { r1 = ret.Get(1).(int64) } - if rf, ok := ret.Get(2).(func(*ethclient.Client) error); ok { - r2 = rf(client) + if rf, ok := ret.Get(2).(func(RPC.RPCParameters) error); ok { + r2 = rf(rpcParameter) } else { r2 = ret.Error(2) } @@ -860,13 +815,13 @@ func (_m *UtilsCmdInterface) GetHTTPTimeout() (int64, error) { return r0, r1 } -// GetIteration provides a mock function with given fields: client, proposer, bufferPercent -func (_m *UtilsCmdInterface) GetIteration(client *ethclient.Client, proposer types.ElectedProposer, bufferPercent int32) int { - ret := _m.Called(client, proposer, bufferPercent) +// GetIteration provides a mock function with given fields: rpcParameters, proposer, bufferPercent +func (_m *UtilsCmdInterface) GetIteration(rpcParameters RPC.RPCParameters, proposer types.ElectedProposer, bufferPercent int32) int { + ret := _m.Called(rpcParameters, proposer, bufferPercent) var r0 int - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.ElectedProposer, int32) int); ok { - r0 = rf(client, proposer, bufferPercent) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.ElectedProposer, int32) int); ok { + r0 = rf(rpcParameters, proposer, bufferPercent) } else { r0 = ret.Get(0).(int) } @@ -874,13 +829,13 @@ func (_m *UtilsCmdInterface) GetIteration(client *ethclient.Client, proposer typ return r0 } -// GetJobList provides a mock function with given fields: client -func (_m *UtilsCmdInterface) GetJobList(client *ethclient.Client) error { - ret := _m.Called(client) +// GetJobList provides a mock function with given fields: rpcParameters +func (_m *UtilsCmdInterface) GetJobList(rpcParameters RPC.RPCParameters) error { + ret := _m.Called(rpcParameters) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) error); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters) error); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Error(0) } @@ -888,23 +843,23 @@ func (_m *UtilsCmdInterface) GetJobList(client *ethclient.Client) error { return r0 } -// GetLocalMediansData provides a mock function with given fields: client, account, epoch, blockNumber, rogueData -func (_m *UtilsCmdInterface) GetLocalMediansData(client *ethclient.Client, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue) (types.ProposeFileData, error) { - ret := _m.Called(client, account, epoch, blockNumber, rogueData) +// GetLocalMediansData provides a mock function with given fields: rpcParameters, account, epoch, blockNumber, rogueData +func (_m *UtilsCmdInterface) GetLocalMediansData(rpcParameters RPC.RPCParameters, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue) (types.ProposeFileData, error) { + ret := _m.Called(rpcParameters, account, epoch, blockNumber, rogueData) var r0 types.ProposeFileData var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Account, uint32, *big.Int, types.Rogue) (types.ProposeFileData, error)); ok { - return rf(client, account, epoch, blockNumber, rogueData) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Account, uint32, *big.Int, types.Rogue) (types.ProposeFileData, error)); ok { + return rf(rpcParameters, account, epoch, blockNumber, rogueData) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Account, uint32, *big.Int, types.Rogue) types.ProposeFileData); ok { - r0 = rf(client, account, epoch, blockNumber, rogueData) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Account, uint32, *big.Int, types.Rogue) types.ProposeFileData); ok { + r0 = rf(rpcParameters, account, epoch, blockNumber, rogueData) } else { r0 = ret.Get(0).(types.ProposeFileData) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Account, uint32, *big.Int, types.Rogue) error); ok { - r1 = rf(client, account, epoch, blockNumber, rogueData) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Account, uint32, *big.Int, types.Rogue) error); ok { + r1 = rf(rpcParameters, account, epoch, blockNumber, rogueData) } else { r1 = ret.Error(1) } @@ -1080,25 +1035,25 @@ func (_m *UtilsCmdInterface) GetRPCTimeout() (int64, error) { return r0, r1 } -// GetSalt provides a mock function with given fields: client, epoch -func (_m *UtilsCmdInterface) GetSalt(client *ethclient.Client, epoch uint32) ([32]byte, error) { - ret := _m.Called(client, epoch) +// GetSalt provides a mock function with given fields: rpcParameters, epoch +func (_m *UtilsCmdInterface) GetSalt(rpcParameters RPC.RPCParameters, epoch uint32) ([32]byte, error) { + ret := _m.Called(rpcParameters, epoch) var r0 [32]byte var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) ([32]byte, error)); ok { - return rf(client, epoch) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint32) ([32]byte, error)); ok { + return rf(rpcParameters, epoch) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) [32]byte); ok { - r0 = rf(client, epoch) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint32) [32]byte); ok { + r0 = rf(rpcParameters, epoch) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([32]byte) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { - r1 = rf(client, epoch) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, epoch) } else { r1 = ret.Error(1) } @@ -1106,32 +1061,32 @@ func (_m *UtilsCmdInterface) GetSalt(client *ethclient.Client, epoch uint32) ([3 return r0, r1 } -// GetSmallestStakeAndId provides a mock function with given fields: client, epoch -func (_m *UtilsCmdInterface) GetSmallestStakeAndId(client *ethclient.Client, epoch uint32) (*big.Int, uint32, error) { - ret := _m.Called(client, epoch) +// GetSmallestStakeAndId provides a mock function with given fields: rpcParameters, epoch +func (_m *UtilsCmdInterface) GetSmallestStakeAndId(rpcParameters RPC.RPCParameters, epoch uint32) (*big.Int, uint32, error) { + ret := _m.Called(rpcParameters, epoch) var r0 *big.Int var r1 uint32 var r2 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (*big.Int, uint32, error)); ok { - return rf(client, epoch) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint32) (*big.Int, uint32, error)); ok { + return rf(rpcParameters, epoch) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) *big.Int); ok { - r0 = rf(client, epoch) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint32) *big.Int); ok { + r0 = rf(rpcParameters, epoch) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) uint32); ok { - r1 = rf(client, epoch) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, uint32) uint32); ok { + r1 = rf(rpcParameters, epoch) } else { r1 = ret.Get(1).(uint32) } - if rf, ok := ret.Get(2).(func(*ethclient.Client, uint32) error); ok { - r2 = rf(client, epoch) + if rf, ok := ret.Get(2).(func(RPC.RPCParameters, uint32) error); ok { + r2 = rf(rpcParameters, epoch) } else { r2 = ret.Error(2) } @@ -1139,25 +1094,25 @@ func (_m *UtilsCmdInterface) GetSmallestStakeAndId(client *ethclient.Client, epo return r0, r1, r2 } -// GetSortedRevealedValues provides a mock function with given fields: client, blockNumber, epoch -func (_m *UtilsCmdInterface) GetSortedRevealedValues(client *ethclient.Client, blockNumber *big.Int, epoch uint32) (*types.RevealedDataMaps, error) { - ret := _m.Called(client, blockNumber, epoch) +// GetSortedRevealedValues provides a mock function with given fields: rpcParameters, blockNumber, epoch +func (_m *UtilsCmdInterface) GetSortedRevealedValues(rpcParameters RPC.RPCParameters, blockNumber *big.Int, epoch uint32) (*types.RevealedDataMaps, error) { + ret := _m.Called(rpcParameters, blockNumber, epoch) var r0 *types.RevealedDataMaps var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, *big.Int, uint32) (*types.RevealedDataMaps, error)); ok { - return rf(client, blockNumber, epoch) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *big.Int, uint32) (*types.RevealedDataMaps, error)); ok { + return rf(rpcParameters, blockNumber, epoch) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, *big.Int, uint32) *types.RevealedDataMaps); ok { - r0 = rf(client, blockNumber, epoch) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *big.Int, uint32) *types.RevealedDataMaps); ok { + r0 = rf(rpcParameters, blockNumber, epoch) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*types.RevealedDataMaps) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, *big.Int, uint32) error); ok { - r1 = rf(client, blockNumber, epoch) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, *big.Int, uint32) error); ok { + r1 = rf(rpcParameters, blockNumber, epoch) } else { r1 = ret.Error(1) } @@ -1165,13 +1120,13 @@ func (_m *UtilsCmdInterface) GetSortedRevealedValues(client *ethclient.Client, b return r0, r1 } -// GetStakerInfo provides a mock function with given fields: client, stakerId -func (_m *UtilsCmdInterface) GetStakerInfo(client *ethclient.Client, stakerId uint32) error { - ret := _m.Called(client, stakerId) +// GetStakerInfo provides a mock function with given fields: rpcParameters, stakerId +func (_m *UtilsCmdInterface) GetStakerInfo(rpcParameters RPC.RPCParameters, stakerId uint32) error { + ret := _m.Called(rpcParameters, stakerId) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) error); ok { - r0 = rf(client, stakerId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint32) error); ok { + r0 = rf(rpcParameters, stakerId) } else { r0 = ret.Error(0) } @@ -1203,13 +1158,13 @@ func (_m *UtilsCmdInterface) GetWaitTime() (int32, error) { return r0, r1 } -// GiveSorted provides a mock function with given fields: client, blockManager, txnArgs, epoch, assetId, sortedStakers -func (_m *UtilsCmdInterface) GiveSorted(client *ethclient.Client, blockManager *bindings.BlockManager, txnArgs types.TransactionOptions, epoch uint32, assetId uint16, sortedStakers []*big.Int) error { - ret := _m.Called(client, blockManager, txnArgs, epoch, assetId, sortedStakers) +// GiveSorted provides a mock function with given fields: rpcParameters, txnArgs, epoch, assetId, sortedStakers +func (_m *UtilsCmdInterface) GiveSorted(rpcParameters RPC.RPCParameters, txnArgs types.TransactionOptions, epoch uint32, assetId uint16, sortedStakers []*big.Int) error { + ret := _m.Called(rpcParameters, txnArgs, epoch, assetId, sortedStakers) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, *bindings.BlockManager, types.TransactionOptions, uint32, uint16, []*big.Int) error); ok { - r0 = rf(client, blockManager, txnArgs, epoch, assetId, sortedStakers) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions, uint32, uint16, []*big.Int) error); ok { + r0 = rf(rpcParameters, txnArgs, epoch, assetId, sortedStakers) } else { r0 = ret.Error(0) } @@ -1217,18 +1172,18 @@ func (_m *UtilsCmdInterface) GiveSorted(client *ethclient.Client, blockManager * return r0 } -// HandleBlock provides a mock function with given fields: client, account, stakerId, header, config, commitParams, rogueData, backupNodeActionsToIgnore -func (_m *UtilsCmdInterface) HandleBlock(client *ethclient.Client, account types.Account, stakerId uint32, header *coretypes.Header, config types.Configurations, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) { - _m.Called(client, account, stakerId, header, config, commitParams, rogueData, backupNodeActionsToIgnore) +// HandleBlock provides a mock function with given fields: rpcParameters, account, stakerId, header, config, commitParams, rogueData, backupNodeActionsToIgnore +func (_m *UtilsCmdInterface) HandleBlock(rpcParameters RPC.RPCParameters, account types.Account, stakerId uint32, header *coretypes.Header, config types.Configurations, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) { + _m.Called(rpcParameters, account, stakerId, header, config, commitParams, rogueData, backupNodeActionsToIgnore) } -// HandleClaimBounty provides a mock function with given fields: client, config, account -func (_m *UtilsCmdInterface) HandleClaimBounty(client *ethclient.Client, config types.Configurations, account types.Account) error { - ret := _m.Called(client, config, account) +// HandleClaimBounty provides a mock function with given fields: rpcParameters, config, account +func (_m *UtilsCmdInterface) HandleClaimBounty(rpcParameters RPC.RPCParameters, config types.Configurations, account types.Account) error { + ret := _m.Called(rpcParameters, config, account) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.Account) error); ok { - r0 = rf(client, config, account) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.Account) error); ok { + r0 = rf(rpcParameters, config, account) } else { r0 = ret.Error(0) } @@ -1236,23 +1191,23 @@ func (_m *UtilsCmdInterface) HandleClaimBounty(client *ethclient.Client, config return r0 } -// HandleCommitState provides a mock function with given fields: client, epoch, seed, commitParams, rogueData -func (_m *UtilsCmdInterface) HandleCommitState(client *ethclient.Client, epoch uint32, seed []byte, commitParams *types.CommitParams, rogueData types.Rogue) (types.CommitData, error) { - ret := _m.Called(client, epoch, seed, commitParams, rogueData) +// HandleCommitState provides a mock function with given fields: rpcParameters, epoch, seed, commitParams, rogueData +func (_m *UtilsCmdInterface) HandleCommitState(rpcParameters RPC.RPCParameters, epoch uint32, seed []byte, commitParams *types.CommitParams, rogueData types.Rogue) (types.CommitData, error) { + ret := _m.Called(rpcParameters, epoch, seed, commitParams, rogueData) var r0 types.CommitData var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, []byte, *types.CommitParams, types.Rogue) (types.CommitData, error)); ok { - return rf(client, epoch, seed, commitParams, rogueData) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint32, []byte, *types.CommitParams, types.Rogue) (types.CommitData, error)); ok { + return rf(rpcParameters, epoch, seed, commitParams, rogueData) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, []byte, *types.CommitParams, types.Rogue) types.CommitData); ok { - r0 = rf(client, epoch, seed, commitParams, rogueData) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint32, []byte, *types.CommitParams, types.Rogue) types.CommitData); ok { + r0 = rf(rpcParameters, epoch, seed, commitParams, rogueData) } else { r0 = ret.Get(0).(types.CommitData) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, []byte, *types.CommitParams, types.Rogue) error); ok { - r1 = rf(client, epoch, seed, commitParams, rogueData) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, uint32, []byte, *types.CommitParams, types.Rogue) error); ok { + r1 = rf(rpcParameters, epoch, seed, commitParams, rogueData) } else { r1 = ret.Error(1) } @@ -1260,13 +1215,13 @@ func (_m *UtilsCmdInterface) HandleCommitState(client *ethclient.Client, epoch u return r0, r1 } -// HandleDispute provides a mock function with given fields: client, config, account, epoch, blockNumber, rogueData, backupNodeActionsToIgnore -func (_m *UtilsCmdInterface) HandleDispute(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue, backupNodeActionsToIgnore []string) error { - ret := _m.Called(client, config, account, epoch, blockNumber, rogueData, backupNodeActionsToIgnore) +// HandleDispute provides a mock function with given fields: rpcParameters, config, account, epoch, blockNumber, rogueData, backupNodeActionsToIgnore +func (_m *UtilsCmdInterface) HandleDispute(rpcParameters RPC.RPCParameters, config types.Configurations, account types.Account, epoch uint32, blockNumber *big.Int, rogueData types.Rogue, backupNodeActionsToIgnore []string) error { + ret := _m.Called(rpcParameters, config, account, epoch, blockNumber, rogueData, backupNodeActionsToIgnore) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.Account, uint32, *big.Int, types.Rogue, []string) error); ok { - r0 = rf(client, config, account, epoch, blockNumber, rogueData, backupNodeActionsToIgnore) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.Account, uint32, *big.Int, types.Rogue, []string) error); ok { + r0 = rf(rpcParameters, config, account, epoch, blockNumber, rogueData, backupNodeActionsToIgnore) } else { r0 = ret.Error(0) } @@ -1279,25 +1234,25 @@ func (_m *UtilsCmdInterface) HandleExit() { _m.Called() } -// HandleUnstakeLock provides a mock function with given fields: client, account, configurations, stakerId -func (_m *UtilsCmdInterface) HandleUnstakeLock(client *ethclient.Client, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) { - ret := _m.Called(client, account, configurations, stakerId) +// HandleUnstakeLock provides a mock function with given fields: rpcParameters, account, configurations, stakerId +func (_m *UtilsCmdInterface) HandleUnstakeLock(rpcParameters RPC.RPCParameters, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) { + ret := _m.Called(rpcParameters, account, configurations, stakerId) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Account, types.Configurations, uint32) (common.Hash, error)); ok { - return rf(client, account, configurations, stakerId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Account, types.Configurations, uint32) (common.Hash, error)); ok { + return rf(rpcParameters, account, configurations, stakerId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Account, types.Configurations, uint32) common.Hash); ok { - r0 = rf(client, account, configurations, stakerId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Account, types.Configurations, uint32) common.Hash); ok { + r0 = rf(rpcParameters, account, configurations, stakerId) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Account, types.Configurations, uint32) error); ok { - r1 = rf(client, account, configurations, stakerId) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Account, types.Configurations, uint32) error); ok { + r1 = rf(rpcParameters, account, configurations, stakerId) } else { r1 = ret.Error(1) } @@ -1305,25 +1260,25 @@ func (_m *UtilsCmdInterface) HandleUnstakeLock(client *ethclient.Client, account return r0, r1 } -// HandleWithdrawLock provides a mock function with given fields: client, account, configurations, stakerId -func (_m *UtilsCmdInterface) HandleWithdrawLock(client *ethclient.Client, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) { - ret := _m.Called(client, account, configurations, stakerId) +// HandleWithdrawLock provides a mock function with given fields: rpcParameters, account, configurations, stakerId +func (_m *UtilsCmdInterface) HandleWithdrawLock(rpcParameters RPC.RPCParameters, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) { + ret := _m.Called(rpcParameters, account, configurations, stakerId) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Account, types.Configurations, uint32) (common.Hash, error)); ok { - return rf(client, account, configurations, stakerId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Account, types.Configurations, uint32) (common.Hash, error)); ok { + return rf(rpcParameters, account, configurations, stakerId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Account, types.Configurations, uint32) common.Hash); ok { - r0 = rf(client, account, configurations, stakerId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Account, types.Configurations, uint32) common.Hash); ok { + r0 = rf(rpcParameters, account, configurations, stakerId) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Account, types.Configurations, uint32) error); ok { - r1 = rf(client, account, configurations, stakerId) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Account, types.Configurations, uint32) error); ok { + r1 = rf(rpcParameters, account, configurations, stakerId) } else { r1 = ret.Error(1) } @@ -1355,25 +1310,25 @@ func (_m *UtilsCmdInterface) ImportAccount() (accounts.Account, error) { return r0, r1 } -// IndexRevealEventsOfCurrentEpoch provides a mock function with given fields: client, blockNumber, epoch -func (_m *UtilsCmdInterface) IndexRevealEventsOfCurrentEpoch(client *ethclient.Client, blockNumber *big.Int, epoch uint32) ([]types.RevealedStruct, error) { - ret := _m.Called(client, blockNumber, epoch) +// IndexRevealEventsOfCurrentEpoch provides a mock function with given fields: rpcParameters, blockNumber, epoch +func (_m *UtilsCmdInterface) IndexRevealEventsOfCurrentEpoch(rpcParameters RPC.RPCParameters, blockNumber *big.Int, epoch uint32) ([]types.RevealedStruct, error) { + ret := _m.Called(rpcParameters, blockNumber, epoch) var r0 []types.RevealedStruct var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, *big.Int, uint32) ([]types.RevealedStruct, error)); ok { - return rf(client, blockNumber, epoch) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *big.Int, uint32) ([]types.RevealedStruct, error)); ok { + return rf(rpcParameters, blockNumber, epoch) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, *big.Int, uint32) []types.RevealedStruct); ok { - r0 = rf(client, blockNumber, epoch) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *big.Int, uint32) []types.RevealedStruct); ok { + r0 = rf(rpcParameters, blockNumber, epoch) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]types.RevealedStruct) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, *big.Int, uint32) error); ok { - r1 = rf(client, blockNumber, epoch) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, *big.Int, uint32) error); ok { + r1 = rf(rpcParameters, blockNumber, epoch) } else { r1 = ret.Error(1) } @@ -1381,43 +1336,43 @@ func (_m *UtilsCmdInterface) IndexRevealEventsOfCurrentEpoch(client *ethclient.C return r0, r1 } -// InitJobAndCollectionCache provides a mock function with given fields: client -func (_m *UtilsCmdInterface) InitJobAndCollectionCache(client *ethclient.Client) (*cache.JobsCache, *cache.CollectionsCache, *big.Int, error) { - ret := _m.Called(client) +// InitJobAndCollectionCache provides a mock function with given fields: rpcParameters +func (_m *UtilsCmdInterface) InitJobAndCollectionCache(rpcParameters RPC.RPCParameters) (*cache.JobsCache, *cache.CollectionsCache, *big.Int, error) { + ret := _m.Called(rpcParameters) var r0 *cache.JobsCache var r1 *cache.CollectionsCache var r2 *big.Int var r3 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (*cache.JobsCache, *cache.CollectionsCache, *big.Int, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters) (*cache.JobsCache, *cache.CollectionsCache, *big.Int, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) *cache.JobsCache); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters) *cache.JobsCache); ok { + r0 = rf(rpcParameters) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*cache.JobsCache) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client) *cache.CollectionsCache); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters) *cache.CollectionsCache); ok { + r1 = rf(rpcParameters) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*cache.CollectionsCache) } } - if rf, ok := ret.Get(2).(func(*ethclient.Client) *big.Int); ok { - r2 = rf(client) + if rf, ok := ret.Get(2).(func(RPC.RPCParameters) *big.Int); ok { + r2 = rf(rpcParameters) } else { if ret.Get(2) != nil { r2 = ret.Get(2).(*big.Int) } } - if rf, ok := ret.Get(3).(func(*ethclient.Client) error); ok { - r3 = rf(client) + if rf, ok := ret.Get(3).(func(RPC.RPCParameters) error); ok { + r3 = rf(rpcParameters) } else { r3 = ret.Error(3) } @@ -1425,13 +1380,13 @@ func (_m *UtilsCmdInterface) InitJobAndCollectionCache(client *ethclient.Client) return r0, r1, r2, r3 } -// InitiateCommit provides a mock function with given fields: client, config, account, epoch, stakerId, latestHeader, commitParams, rogueData -func (_m *UtilsCmdInterface) InitiateCommit(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, stakerId uint32, latestHeader *coretypes.Header, commitParams *types.CommitParams, rogueData types.Rogue) error { - ret := _m.Called(client, config, account, epoch, stakerId, latestHeader, commitParams, rogueData) +// InitiateCommit provides a mock function with given fields: rpcParameters, config, account, epoch, stakerId, latestHeader, commitParams, stateBuffer, rogueData +func (_m *UtilsCmdInterface) InitiateCommit(rpcParameters RPC.RPCParameters, config types.Configurations, account types.Account, epoch uint32, stakerId uint32, latestHeader *coretypes.Header, commitParams *types.CommitParams, stateBuffer uint64, rogueData types.Rogue) error { + ret := _m.Called(rpcParameters, config, account, epoch, stakerId, latestHeader, commitParams, stateBuffer, rogueData) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.Account, uint32, uint32, *coretypes.Header, *types.CommitParams, types.Rogue) error); ok { - r0 = rf(client, config, account, epoch, stakerId, latestHeader, commitParams, rogueData) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.Account, uint32, uint32, *coretypes.Header, *types.CommitParams, uint64, types.Rogue) error); ok { + r0 = rf(rpcParameters, config, account, epoch, stakerId, latestHeader, commitParams, stateBuffer, rogueData) } else { r0 = ret.Error(0) } @@ -1439,13 +1394,13 @@ func (_m *UtilsCmdInterface) InitiateCommit(client *ethclient.Client, config typ return r0 } -// InitiatePropose provides a mock function with given fields: client, config, account, epoch, staker, latestHeader, rogueData -func (_m *UtilsCmdInterface) InitiatePropose(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *coretypes.Header, rogueData types.Rogue) error { - ret := _m.Called(client, config, account, epoch, staker, latestHeader, rogueData) +// InitiatePropose provides a mock function with given fields: rpcParameters, config, account, epoch, staker, latestHeader, stateBuffer, rogueData +func (_m *UtilsCmdInterface) InitiatePropose(rpcParameters RPC.RPCParameters, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *coretypes.Header, stateBuffer uint64, rogueData types.Rogue) error { + ret := _m.Called(rpcParameters, config, account, epoch, staker, latestHeader, stateBuffer, rogueData) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.Account, uint32, bindings.StructsStaker, *coretypes.Header, types.Rogue) error); ok { - r0 = rf(client, config, account, epoch, staker, latestHeader, rogueData) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.Account, uint32, bindings.StructsStaker, *coretypes.Header, uint64, types.Rogue) error); ok { + r0 = rf(rpcParameters, config, account, epoch, staker, latestHeader, stateBuffer, rogueData) } else { r0 = ret.Error(0) } @@ -1453,13 +1408,13 @@ func (_m *UtilsCmdInterface) InitiatePropose(client *ethclient.Client, config ty return r0 } -// InitiateReveal provides a mock function with given fields: client, config, account, epoch, staker, latestHeader, rogueData -func (_m *UtilsCmdInterface) InitiateReveal(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *coretypes.Header, rogueData types.Rogue) error { - ret := _m.Called(client, config, account, epoch, staker, latestHeader, rogueData) +// InitiateReveal provides a mock function with given fields: rpcParameters, config, account, epoch, staker, latestHeader, stateBuffer, rogueData +func (_m *UtilsCmdInterface) InitiateReveal(rpcParameters RPC.RPCParameters, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *coretypes.Header, stateBuffer uint64, rogueData types.Rogue) error { + ret := _m.Called(rpcParameters, config, account, epoch, staker, latestHeader, stateBuffer, rogueData) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.Account, uint32, bindings.StructsStaker, *coretypes.Header, types.Rogue) error); ok { - r0 = rf(client, config, account, epoch, staker, latestHeader, rogueData) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.Account, uint32, bindings.StructsStaker, *coretypes.Header, uint64, types.Rogue) error); ok { + r0 = rf(rpcParameters, config, account, epoch, staker, latestHeader, stateBuffer, rogueData) } else { r0 = ret.Error(0) } @@ -1467,25 +1422,25 @@ func (_m *UtilsCmdInterface) InitiateReveal(client *ethclient.Client, config typ return r0 } -// InitiateWithdraw provides a mock function with given fields: client, txnOpts, stakerId -func (_m *UtilsCmdInterface) InitiateWithdraw(client *ethclient.Client, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) { - ret := _m.Called(client, txnOpts, stakerId) +// InitiateWithdraw provides a mock function with given fields: rpcParameters, txnOpts, stakerId +func (_m *UtilsCmdInterface) InitiateWithdraw(rpcParameters RPC.RPCParameters, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) { + ret := _m.Called(rpcParameters, txnOpts, stakerId) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) (common.Hash, error)); ok { - return rf(client, txnOpts, stakerId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *bind.TransactOpts, uint32) (common.Hash, error)); ok { + return rf(rpcParameters, txnOpts, stakerId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) common.Hash); ok { - r0 = rf(client, txnOpts, stakerId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *bind.TransactOpts, uint32) common.Hash); ok { + r0 = rf(rpcParameters, txnOpts, stakerId) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32) error); ok { - r1 = rf(client, txnOpts, stakerId) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, *bind.TransactOpts, uint32) error); ok { + r1 = rf(rpcParameters, txnOpts, stakerId) } else { r1 = ret.Error(1) } @@ -1533,43 +1488,43 @@ func (_m *UtilsCmdInterface) ListAccounts() ([]accounts.Account, error) { return r0, r1 } -// MakeBlock provides a mock function with given fields: client, blockNumber, epoch, rogueData -func (_m *UtilsCmdInterface) MakeBlock(client *ethclient.Client, blockNumber *big.Int, epoch uint32, rogueData types.Rogue) ([]*big.Int, []uint16, *types.RevealedDataMaps, error) { - ret := _m.Called(client, blockNumber, epoch, rogueData) +// MakeBlock provides a mock function with given fields: rpcParameters, blockNumber, epoch, rogueData +func (_m *UtilsCmdInterface) MakeBlock(rpcParameters RPC.RPCParameters, blockNumber *big.Int, epoch uint32, rogueData types.Rogue) ([]*big.Int, []uint16, *types.RevealedDataMaps, error) { + ret := _m.Called(rpcParameters, blockNumber, epoch, rogueData) var r0 []*big.Int var r1 []uint16 var r2 *types.RevealedDataMaps var r3 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, *big.Int, uint32, types.Rogue) ([]*big.Int, []uint16, *types.RevealedDataMaps, error)); ok { - return rf(client, blockNumber, epoch, rogueData) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *big.Int, uint32, types.Rogue) ([]*big.Int, []uint16, *types.RevealedDataMaps, error)); ok { + return rf(rpcParameters, blockNumber, epoch, rogueData) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, *big.Int, uint32, types.Rogue) []*big.Int); ok { - r0 = rf(client, blockNumber, epoch, rogueData) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *big.Int, uint32, types.Rogue) []*big.Int); ok { + r0 = rf(rpcParameters, blockNumber, epoch, rogueData) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, *big.Int, uint32, types.Rogue) []uint16); ok { - r1 = rf(client, blockNumber, epoch, rogueData) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, *big.Int, uint32, types.Rogue) []uint16); ok { + r1 = rf(rpcParameters, blockNumber, epoch, rogueData) } else { if ret.Get(1) != nil { r1 = ret.Get(1).([]uint16) } } - if rf, ok := ret.Get(2).(func(*ethclient.Client, *big.Int, uint32, types.Rogue) *types.RevealedDataMaps); ok { - r2 = rf(client, blockNumber, epoch, rogueData) + if rf, ok := ret.Get(2).(func(RPC.RPCParameters, *big.Int, uint32, types.Rogue) *types.RevealedDataMaps); ok { + r2 = rf(rpcParameters, blockNumber, epoch, rogueData) } else { if ret.Get(2) != nil { r2 = ret.Get(2).(*types.RevealedDataMaps) } } - if rf, ok := ret.Get(3).(func(*ethclient.Client, *big.Int, uint32, types.Rogue) error); ok { - r3 = rf(client, blockNumber, epoch, rogueData) + if rf, ok := ret.Get(3).(func(RPC.RPCParameters, *big.Int, uint32, types.Rogue) error); ok { + r3 = rf(rpcParameters, blockNumber, epoch, rogueData) } else { r3 = ret.Error(3) } @@ -1577,25 +1532,25 @@ func (_m *UtilsCmdInterface) MakeBlock(client *ethclient.Client, blockNumber *bi return r0, r1, r2, r3 } -// ModifyCollectionStatus provides a mock function with given fields: client, config, modifyCollectionInput -func (_m *UtilsCmdInterface) ModifyCollectionStatus(client *ethclient.Client, config types.Configurations, modifyCollectionInput types.ModifyCollectionInput) (common.Hash, error) { - ret := _m.Called(client, config, modifyCollectionInput) +// ModifyCollectionStatus provides a mock function with given fields: rpcParameters, config, modifyCollectionInput +func (_m *UtilsCmdInterface) ModifyCollectionStatus(rpcParameters RPC.RPCParameters, config types.Configurations, modifyCollectionInput types.ModifyCollectionInput) (common.Hash, error) { + ret := _m.Called(rpcParameters, config, modifyCollectionInput) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.ModifyCollectionInput) (common.Hash, error)); ok { - return rf(client, config, modifyCollectionInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.ModifyCollectionInput) (common.Hash, error)); ok { + return rf(rpcParameters, config, modifyCollectionInput) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.ModifyCollectionInput) common.Hash); ok { - r0 = rf(client, config, modifyCollectionInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.ModifyCollectionInput) common.Hash); ok { + r0 = rf(rpcParameters, config, modifyCollectionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Configurations, types.ModifyCollectionInput) error); ok { - r1 = rf(client, config, modifyCollectionInput) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.ModifyCollectionInput) error); ok { + r1 = rf(rpcParameters, config, modifyCollectionInput) } else { r1 = ret.Error(1) } @@ -1603,13 +1558,13 @@ func (_m *UtilsCmdInterface) ModifyCollectionStatus(client *ethclient.Client, co return r0, r1 } -// Propose provides a mock function with given fields: client, config, account, staker, epoch, latestHeader, rogueData -func (_m *UtilsCmdInterface) Propose(client *ethclient.Client, config types.Configurations, account types.Account, staker bindings.StructsStaker, epoch uint32, latestHeader *coretypes.Header, rogueData types.Rogue) error { - ret := _m.Called(client, config, account, staker, epoch, latestHeader, rogueData) +// Propose provides a mock function with given fields: rpcParameters, config, account, staker, epoch, latestHeader, stateBuffer, rogueData +func (_m *UtilsCmdInterface) Propose(rpcParameters RPC.RPCParameters, config types.Configurations, account types.Account, staker bindings.StructsStaker, epoch uint32, latestHeader *coretypes.Header, stateBuffer uint64, rogueData types.Rogue) error { + ret := _m.Called(rpcParameters, config, account, staker, epoch, latestHeader, stateBuffer, rogueData) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.Account, bindings.StructsStaker, uint32, *coretypes.Header, types.Rogue) error); ok { - r0 = rf(client, config, account, staker, epoch, latestHeader, rogueData) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.Account, bindings.StructsStaker, uint32, *coretypes.Header, uint64, types.Rogue) error); ok { + r0 = rf(rpcParameters, config, account, staker, epoch, latestHeader, stateBuffer, rogueData) } else { r0 = ret.Error(0) } @@ -1617,30 +1572,30 @@ func (_m *UtilsCmdInterface) Propose(client *ethclient.Client, config types.Conf return r0 } -// ResetDispute provides a mock function with given fields: client, blockManager, txnOpts, epoch -func (_m *UtilsCmdInterface) ResetDispute(client *ethclient.Client, blockManager *bindings.BlockManager, txnOpts *bind.TransactOpts, epoch uint32) { - _m.Called(client, blockManager, txnOpts, epoch) +// ResetDispute provides a mock function with given fields: rpcParameters, txnOpts, epoch +func (_m *UtilsCmdInterface) ResetDispute(rpcParameters RPC.RPCParameters, txnOpts *bind.TransactOpts, epoch uint32) { + _m.Called(rpcParameters, txnOpts, epoch) } -// ResetUnstakeLock provides a mock function with given fields: client, config, extendLockInput -func (_m *UtilsCmdInterface) ResetUnstakeLock(client *ethclient.Client, config types.Configurations, extendLockInput types.ExtendLockInput) (common.Hash, error) { - ret := _m.Called(client, config, extendLockInput) +// ResetUnstakeLock provides a mock function with given fields: rpcParameters, config, extendLockInput +func (_m *UtilsCmdInterface) ResetUnstakeLock(rpcParameters RPC.RPCParameters, config types.Configurations, extendLockInput types.ExtendLockInput) (common.Hash, error) { + ret := _m.Called(rpcParameters, config, extendLockInput) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.ExtendLockInput) (common.Hash, error)); ok { - return rf(client, config, extendLockInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.ExtendLockInput) (common.Hash, error)); ok { + return rf(rpcParameters, config, extendLockInput) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.ExtendLockInput) common.Hash); ok { - r0 = rf(client, config, extendLockInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.ExtendLockInput) common.Hash); ok { + r0 = rf(rpcParameters, config, extendLockInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Configurations, types.ExtendLockInput) error); ok { - r1 = rf(client, config, extendLockInput) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.ExtendLockInput) error); ok { + r1 = rf(rpcParameters, config, extendLockInput) } else { r1 = ret.Error(1) } @@ -1648,25 +1603,25 @@ func (_m *UtilsCmdInterface) ResetUnstakeLock(client *ethclient.Client, config t return r0, r1 } -// Reveal provides a mock function with given fields: client, config, account, epoch, latestHeader, commitData, signature -func (_m *UtilsCmdInterface) Reveal(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, latestHeader *coretypes.Header, commitData types.CommitData, signature []byte) (common.Hash, error) { - ret := _m.Called(client, config, account, epoch, latestHeader, commitData, signature) +// Reveal provides a mock function with given fields: rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitData, signature +func (_m *UtilsCmdInterface) Reveal(rpcParameters RPC.RPCParameters, config types.Configurations, account types.Account, epoch uint32, latestHeader *coretypes.Header, stateBuffer uint64, commitData types.CommitData, signature []byte) (common.Hash, error) { + ret := _m.Called(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitData, signature) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.Account, uint32, *coretypes.Header, types.CommitData, []byte) (common.Hash, error)); ok { - return rf(client, config, account, epoch, latestHeader, commitData, signature) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.Account, uint32, *coretypes.Header, uint64, types.CommitData, []byte) (common.Hash, error)); ok { + return rf(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitData, signature) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.Account, uint32, *coretypes.Header, types.CommitData, []byte) common.Hash); ok { - r0 = rf(client, config, account, epoch, latestHeader, commitData, signature) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.Account, uint32, *coretypes.Header, uint64, types.CommitData, []byte) common.Hash); ok { + r0 = rf(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitData, signature) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Configurations, types.Account, uint32, *coretypes.Header, types.CommitData, []byte) error); ok { - r1 = rf(client, config, account, epoch, latestHeader, commitData, signature) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.Account, uint32, *coretypes.Header, uint64, types.CommitData, []byte) error); ok { + r1 = rf(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitData, signature) } else { r1 = ret.Error(1) } @@ -1688,25 +1643,25 @@ func (_m *UtilsCmdInterface) SetConfig(flagSet *pflag.FlagSet) error { return r0 } -// SetDelegation provides a mock function with given fields: client, config, delegationInput -func (_m *UtilsCmdInterface) SetDelegation(client *ethclient.Client, config types.Configurations, delegationInput types.SetDelegationInput) (common.Hash, error) { - ret := _m.Called(client, config, delegationInput) +// SetDelegation provides a mock function with given fields: rpcParameters, config, delegationInput +func (_m *UtilsCmdInterface) SetDelegation(rpcParameters RPC.RPCParameters, config types.Configurations, delegationInput types.SetDelegationInput) (common.Hash, error) { + ret := _m.Called(rpcParameters, config, delegationInput) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.SetDelegationInput) (common.Hash, error)); ok { - return rf(client, config, delegationInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.SetDelegationInput) (common.Hash, error)); ok { + return rf(rpcParameters, config, delegationInput) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.SetDelegationInput) common.Hash); ok { - r0 = rf(client, config, delegationInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.SetDelegationInput) common.Hash); ok { + r0 = rf(rpcParameters, config, delegationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Configurations, types.SetDelegationInput) error); ok { - r1 = rf(client, config, delegationInput) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.SetDelegationInput) error); ok { + r1 = rf(rpcParameters, config, delegationInput) } else { r1 = ret.Error(1) } @@ -1714,25 +1669,25 @@ func (_m *UtilsCmdInterface) SetDelegation(client *ethclient.Client, config type return r0, r1 } -// StakeCoins provides a mock function with given fields: txnArgs -func (_m *UtilsCmdInterface) StakeCoins(txnArgs types.TransactionOptions) (common.Hash, error) { - ret := _m.Called(txnArgs) +// StakeCoins provides a mock function with given fields: rpcParameters, txnArgs +func (_m *UtilsCmdInterface) StakeCoins(rpcParameters RPC.RPCParameters, txnArgs types.TransactionOptions) (common.Hash, error) { + ret := _m.Called(rpcParameters, txnArgs) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(types.TransactionOptions) (common.Hash, error)); ok { - return rf(txnArgs) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions) (common.Hash, error)); ok { + return rf(rpcParameters, txnArgs) } - if rf, ok := ret.Get(0).(func(types.TransactionOptions) common.Hash); ok { - r0 = rf(txnArgs) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions) common.Hash); ok { + r0 = rf(rpcParameters, txnArgs) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(types.TransactionOptions) error); ok { - r1 = rf(txnArgs) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.TransactionOptions) error); ok { + r1 = rf(rpcParameters, txnArgs) } else { r1 = ret.Error(1) } @@ -1740,13 +1695,13 @@ func (_m *UtilsCmdInterface) StakeCoins(txnArgs types.TransactionOptions) (commo return r0, r1 } -// StoreBountyId provides a mock function with given fields: client, account -func (_m *UtilsCmdInterface) StoreBountyId(client *ethclient.Client, account types.Account) error { - ret := _m.Called(client, account) +// StoreBountyId provides a mock function with given fields: rpcParameters, account +func (_m *UtilsCmdInterface) StoreBountyId(rpcParameters RPC.RPCParameters, account types.Account) error { + ret := _m.Called(rpcParameters, account) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Account) error); ok { - r0 = rf(client, account) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Account) error); ok { + r0 = rf(rpcParameters, account) } else { r0 = ret.Error(0) } @@ -1754,25 +1709,25 @@ func (_m *UtilsCmdInterface) StoreBountyId(client *ethclient.Client, account typ return r0 } -// Transfer provides a mock function with given fields: client, config, transferInput -func (_m *UtilsCmdInterface) Transfer(client *ethclient.Client, config types.Configurations, transferInput types.TransferInput) (common.Hash, error) { - ret := _m.Called(client, config, transferInput) +// Transfer provides a mock function with given fields: rpcParameters, config, transferInput +func (_m *UtilsCmdInterface) Transfer(rpcParameters RPC.RPCParameters, config types.Configurations, transferInput types.TransferInput) (common.Hash, error) { + ret := _m.Called(rpcParameters, config, transferInput) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.TransferInput) (common.Hash, error)); ok { - return rf(client, config, transferInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.TransferInput) (common.Hash, error)); ok { + return rf(rpcParameters, config, transferInput) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.TransferInput) common.Hash); ok { - r0 = rf(client, config, transferInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.TransferInput) common.Hash); ok { + r0 = rf(rpcParameters, config, transferInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Configurations, types.TransferInput) error); ok { - r1 = rf(client, config, transferInput) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.TransferInput) error); ok { + r1 = rf(rpcParameters, config, transferInput) } else { r1 = ret.Error(1) } @@ -1780,25 +1735,25 @@ func (_m *UtilsCmdInterface) Transfer(client *ethclient.Client, config types.Con return r0, r1 } -// UnlockWithdraw provides a mock function with given fields: client, txnOpts, stakerId -func (_m *UtilsCmdInterface) UnlockWithdraw(client *ethclient.Client, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) { - ret := _m.Called(client, txnOpts, stakerId) +// UnlockWithdraw provides a mock function with given fields: rpcParameters, txnOpts, stakerId +func (_m *UtilsCmdInterface) UnlockWithdraw(rpcParameters RPC.RPCParameters, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) { + ret := _m.Called(rpcParameters, txnOpts, stakerId) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) (common.Hash, error)); ok { - return rf(client, txnOpts, stakerId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *bind.TransactOpts, uint32) (common.Hash, error)); ok { + return rf(rpcParameters, txnOpts, stakerId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32) common.Hash); ok { - r0 = rf(client, txnOpts, stakerId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *bind.TransactOpts, uint32) common.Hash); ok { + r0 = rf(rpcParameters, txnOpts, stakerId) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32) error); ok { - r1 = rf(client, txnOpts, stakerId) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, *bind.TransactOpts, uint32) error); ok { + r1 = rf(rpcParameters, txnOpts, stakerId) } else { r1 = ret.Error(1) } @@ -1806,25 +1761,25 @@ func (_m *UtilsCmdInterface) UnlockWithdraw(client *ethclient.Client, txnOpts *b return r0, r1 } -// Unstake provides a mock function with given fields: config, client, input -func (_m *UtilsCmdInterface) Unstake(config types.Configurations, client *ethclient.Client, input types.UnstakeInput) (common.Hash, error) { - ret := _m.Called(config, client, input) +// Unstake provides a mock function with given fields: rpcParameters, config, input +func (_m *UtilsCmdInterface) Unstake(rpcParameters RPC.RPCParameters, config types.Configurations, input types.UnstakeInput) (common.Hash, error) { + ret := _m.Called(rpcParameters, config, input) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(types.Configurations, *ethclient.Client, types.UnstakeInput) (common.Hash, error)); ok { - return rf(config, client, input) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.UnstakeInput) (common.Hash, error)); ok { + return rf(rpcParameters, config, input) } - if rf, ok := ret.Get(0).(func(types.Configurations, *ethclient.Client, types.UnstakeInput) common.Hash); ok { - r0 = rf(config, client, input) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.UnstakeInput) common.Hash); ok { + r0 = rf(rpcParameters, config, input) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(types.Configurations, *ethclient.Client, types.UnstakeInput) error); ok { - r1 = rf(config, client, input) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.UnstakeInput) error); ok { + r1 = rf(rpcParameters, config, input) } else { r1 = ret.Error(1) } @@ -1832,25 +1787,25 @@ func (_m *UtilsCmdInterface) Unstake(config types.Configurations, client *ethcli return r0, r1 } -// UpdateCollection provides a mock function with given fields: client, config, collectionInput, collectionId -func (_m *UtilsCmdInterface) UpdateCollection(client *ethclient.Client, config types.Configurations, collectionInput types.CreateCollectionInput, collectionId uint16) (common.Hash, error) { - ret := _m.Called(client, config, collectionInput, collectionId) +// UpdateCollection provides a mock function with given fields: rpcParameters, config, collectionInput, collectionId +func (_m *UtilsCmdInterface) UpdateCollection(rpcParameters RPC.RPCParameters, config types.Configurations, collectionInput types.CreateCollectionInput, collectionId uint16) (common.Hash, error) { + ret := _m.Called(rpcParameters, config, collectionInput, collectionId) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.CreateCollectionInput, uint16) (common.Hash, error)); ok { - return rf(client, config, collectionInput, collectionId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.CreateCollectionInput, uint16) (common.Hash, error)); ok { + return rf(rpcParameters, config, collectionInput, collectionId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.CreateCollectionInput, uint16) common.Hash); ok { - r0 = rf(client, config, collectionInput, collectionId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.CreateCollectionInput, uint16) common.Hash); ok { + r0 = rf(rpcParameters, config, collectionInput, collectionId) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Configurations, types.CreateCollectionInput, uint16) error); ok { - r1 = rf(client, config, collectionInput, collectionId) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.CreateCollectionInput, uint16) error); ok { + r1 = rf(rpcParameters, config, collectionInput, collectionId) } else { r1 = ret.Error(1) } @@ -1858,13 +1813,13 @@ func (_m *UtilsCmdInterface) UpdateCollection(client *ethclient.Client, config t return r0, r1 } -// UpdateCommission provides a mock function with given fields: config, client, updateCommissionInput -func (_m *UtilsCmdInterface) UpdateCommission(config types.Configurations, client *ethclient.Client, updateCommissionInput types.UpdateCommissionInput) error { - ret := _m.Called(config, client, updateCommissionInput) +// UpdateCommission provides a mock function with given fields: rpcParameters, config, updateCommissionInput +func (_m *UtilsCmdInterface) UpdateCommission(rpcParameters RPC.RPCParameters, config types.Configurations, updateCommissionInput types.UpdateCommissionInput) error { + ret := _m.Called(rpcParameters, config, updateCommissionInput) var r0 error - if rf, ok := ret.Get(0).(func(types.Configurations, *ethclient.Client, types.UpdateCommissionInput) error); ok { - r0 = rf(config, client, updateCommissionInput) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.UpdateCommissionInput) error); ok { + r0 = rf(rpcParameters, config, updateCommissionInput) } else { r0 = ret.Error(0) } @@ -1872,25 +1827,25 @@ func (_m *UtilsCmdInterface) UpdateCommission(config types.Configurations, clien return r0 } -// UpdateJob provides a mock function with given fields: client, config, jobInput, jobId -func (_m *UtilsCmdInterface) UpdateJob(client *ethclient.Client, config types.Configurations, jobInput types.CreateJobInput, jobId uint16) (common.Hash, error) { - ret := _m.Called(client, config, jobInput, jobId) +// UpdateJob provides a mock function with given fields: rpcParameters, config, jobInput, jobId +func (_m *UtilsCmdInterface) UpdateJob(rpcParameters RPC.RPCParameters, config types.Configurations, jobInput types.CreateJobInput, jobId uint16) (common.Hash, error) { + ret := _m.Called(rpcParameters, config, jobInput, jobId) var r0 common.Hash var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.CreateJobInput, uint16) (common.Hash, error)); ok { - return rf(client, config, jobInput, jobId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.CreateJobInput, uint16) (common.Hash, error)); ok { + return rf(rpcParameters, config, jobInput, jobId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations, types.CreateJobInput, uint16) common.Hash); ok { - r0 = rf(client, config, jobInput, jobId) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations, types.CreateJobInput, uint16) common.Hash); ok { + r0 = rf(rpcParameters, config, jobInput, jobId) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(common.Hash) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, types.Configurations, types.CreateJobInput, uint16) error); ok { - r1 = rf(client, config, jobInput, jobId) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.Configurations, types.CreateJobInput, uint16) error); ok { + r1 = rf(rpcParameters, config, jobInput, jobId) } else { r1 = ret.Error(1) } @@ -1898,13 +1853,13 @@ func (_m *UtilsCmdInterface) UpdateJob(client *ethclient.Client, config types.Co return r0, r1 } -// Vote provides a mock function with given fields: ctx, config, client, account, stakerId, commitParams, rogueData, backupNodeActionsToIgnore -func (_m *UtilsCmdInterface) Vote(ctx context.Context, config types.Configurations, client *ethclient.Client, account types.Account, stakerId uint32, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) error { - ret := _m.Called(ctx, config, client, account, stakerId, commitParams, rogueData, backupNodeActionsToIgnore) +// Vote provides a mock function with given fields: rpcParameters, config, account, stakerId, commitParams, rogueData, backupNodeActionsToIgnore +func (_m *UtilsCmdInterface) Vote(rpcParameters RPC.RPCParameters, blockMonitor *block.BlockMonitor, config types.Configurations, account types.Account, stakerId uint32, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) error { + ret := _m.Called(rpcParameters, blockMonitor, config, account, stakerId, commitParams, rogueData, backupNodeActionsToIgnore) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, types.Configurations, *ethclient.Client, types.Account, uint32, *types.CommitParams, types.Rogue, []string) error); ok { - r0 = rf(ctx, config, client, account, stakerId, commitParams, rogueData, backupNodeActionsToIgnore) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *block.BlockMonitor, types.Configurations, types.Account, uint32, *types.CommitParams, types.Rogue, []string) error); ok { + r0 = rf(rpcParameters, blockMonitor, config, account, stakerId, commitParams, rogueData, backupNodeActionsToIgnore) } else { r0 = ret.Error(0) } @@ -1912,30 +1867,30 @@ func (_m *UtilsCmdInterface) Vote(ctx context.Context, config types.Configuratio return r0 } -// WaitForAppropriateState provides a mock function with given fields: client, action, states -func (_m *UtilsCmdInterface) WaitForAppropriateState(client *ethclient.Client, action string, states ...int) (uint32, error) { +// WaitForAppropriateState provides a mock function with given fields: rpcParameter, action, states +func (_m *UtilsCmdInterface) WaitForAppropriateState(rpcParameter RPC.RPCParameters, action string, states ...int) (uint32, error) { _va := make([]interface{}, len(states)) for _i := range states { _va[_i] = states[_i] } var _ca []interface{} - _ca = append(_ca, client, action) + _ca = append(_ca, rpcParameter, action) _ca = append(_ca, _va...) ret := _m.Called(_ca...) var r0 uint32 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, string, ...int) (uint32, error)); ok { - return rf(client, action, states...) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, string, ...int) (uint32, error)); ok { + return rf(rpcParameter, action, states...) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, string, ...int) uint32); ok { - r0 = rf(client, action, states...) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, string, ...int) uint32); ok { + r0 = rf(rpcParameter, action, states...) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, string, ...int) error); ok { - r1 = rf(client, action, states...) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, string, ...int) error); ok { + r1 = rf(rpcParameter, action, states...) } else { r1 = ret.Error(1) } @@ -1943,23 +1898,23 @@ func (_m *UtilsCmdInterface) WaitForAppropriateState(client *ethclient.Client, a return r0, r1 } -// WaitIfCommitState provides a mock function with given fields: client, action -func (_m *UtilsCmdInterface) WaitIfCommitState(client *ethclient.Client, action string) (uint32, error) { - ret := _m.Called(client, action) +// WaitIfCommitState provides a mock function with given fields: rpcParameter, action +func (_m *UtilsCmdInterface) WaitIfCommitState(rpcParameter RPC.RPCParameters, action string) (uint32, error) { + ret := _m.Called(rpcParameter, action) var r0 uint32 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, string) (uint32, error)); ok { - return rf(client, action) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, string) (uint32, error)); ok { + return rf(rpcParameter, action) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, string) uint32); ok { - r0 = rf(client, action) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, string) uint32); ok { + r0 = rf(rpcParameter, action) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, string) error); ok { - r1 = rf(client, action) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, string) error); ok { + r1 = rf(rpcParameter, action) } else { r1 = ret.Error(1) } diff --git a/cmd/mocks/viper_interface.go b/cmd/mocks/viper_interface.go index f664ff795..ddbb6674a 100644 --- a/cmd/mocks/viper_interface.go +++ b/cmd/mocks/viper_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -23,13 +23,12 @@ func (_m *ViperInterface) ViperWriteConfigAs(path string) error { return r0 } -type mockConstructorTestingTNewViperInterface interface { +// NewViperInterface creates a new instance of ViperInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewViperInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewViperInterface creates a new instance of ViperInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewViperInterface(t mockConstructorTestingTNewViperInterface) *ViperInterface { +}) *ViperInterface { mock := &ViperInterface{} mock.Mock.Test(t) diff --git a/cmd/mocks/vote_manager_interface.go b/cmd/mocks/vote_manager_interface.go index f9e96332f..8a602d25c 100644 --- a/cmd/mocks/vote_manager_interface.go +++ b/cmd/mocks/vote_manager_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -24,6 +24,10 @@ func (_m *VoteManagerInterface) Commit(client *ethclient.Client, txnOpts *bind.T ret := _m.Called(client, txnOpts, epoch, commitment) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, [32]byte) (*types.Transaction, error)); ok { + return rf(client, txnOpts, epoch, commitment) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, [32]byte) *types.Transaction); ok { r0 = rf(client, txnOpts, epoch, commitment) } else { @@ -32,7 +36,6 @@ func (_m *VoteManagerInterface) Commit(client *ethclient.Client, txnOpts *bind.T } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, [32]byte) error); ok { r1 = rf(client, txnOpts, epoch, commitment) } else { @@ -47,6 +50,10 @@ func (_m *VoteManagerInterface) Reveal(client *ethclient.Client, txnOpts *bind.T ret := _m.Called(client, txnOpts, epoch, tree, signature) var r0 *types.Transaction + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, bindings.StructsMerkleTree, []byte) (*types.Transaction, error)); ok { + return rf(client, txnOpts, epoch, tree, signature) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, *bind.TransactOpts, uint32, bindings.StructsMerkleTree, []byte) *types.Transaction); ok { r0 = rf(client, txnOpts, epoch, tree, signature) } else { @@ -55,7 +62,6 @@ func (_m *VoteManagerInterface) Reveal(client *ethclient.Client, txnOpts *bind.T } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, *bind.TransactOpts, uint32, bindings.StructsMerkleTree, []byte) error); ok { r1 = rf(client, txnOpts, epoch, tree, signature) } else { @@ -65,13 +71,12 @@ func (_m *VoteManagerInterface) Reveal(client *ethclient.Client, txnOpts *bind.T return r0, r1 } -type mockConstructorTestingTNewVoteManagerInterface interface { +// NewVoteManagerInterface creates a new instance of VoteManagerInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewVoteManagerInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewVoteManagerInterface creates a new instance of VoteManagerInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewVoteManagerInterface(t mockConstructorTestingTNewVoteManagerInterface) *VoteManagerInterface { +}) *VoteManagerInterface { mock := &VoteManagerInterface{} mock.Mock.Test(t) diff --git a/cmd/modifyCollectionStatus.go b/cmd/modifyCollectionStatus.go index 7f16efad6..e6b4d1be4 100644 --- a/cmd/modifyCollectionStatus.go +++ b/cmd/modifyCollectionStatus.go @@ -2,15 +2,13 @@ package cmd import ( - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/cobra" "github.com/spf13/pflag" ) @@ -31,31 +29,8 @@ func initialiseModifyCollectionStatus(cmd *cobra.Command, args []string) { //This function sets the flags appropriately and executes the ModifyCollectionStatus function func (*UtilsStruct) ExecuteModifyCollectionStatus(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteModifyCollectionStatus: Config: %+v: ", config) - - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - log.Debug("ExecuteModifyCollectionStatus: Address: ", address) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) collectionId, err := flagSetUtils.GetUint16CollectionId(flagSet) utils.CheckError("Error in getting collectionId: ", err) @@ -72,23 +47,17 @@ func (*UtilsStruct) ExecuteModifyCollectionStatus(flagSet *pflag.FlagSet) { Account: account, } - txn, err := cmdUtils.ModifyCollectionStatus(client, config, modifyCollectionInput) + txn, err := cmdUtils.ModifyCollectionStatus(rpcParameters, config, modifyCollectionInput) utils.CheckError("Error in changing collection active status: ", err) if txn != core.NilHash { - err = razorUtils.WaitForBlockCompletion(client, txn.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txn.Hex()) utils.CheckError("Error in WaitForBlockCompletion for modifyCollectionStatus: ", err) } } -//This function checks the current status of particular collectionId -func (*UtilsStruct) CheckCurrentStatus(client *ethclient.Client, collectionId uint16) (bool, error) { - callOpts := razorUtils.GetOptions() - return assetManagerUtils.GetActiveStatus(client, &callOpts, collectionId) -} - //This function allows the admin to modify the active status of collection -func (*UtilsStruct) ModifyCollectionStatus(client *ethclient.Client, config types.Configurations, modifyCollectionInput types.ModifyCollectionInput) (common.Hash, error) { - currentStatus, err := cmdUtils.CheckCurrentStatus(client, modifyCollectionInput.CollectionId) +func (*UtilsStruct) ModifyCollectionStatus(rpcParameters rpc.RPCParameters, config types.Configurations, modifyCollectionInput types.ModifyCollectionInput) (common.Hash, error) { + currentStatus, err := razorUtils.GetActiveStatus(rpcParameters, modifyCollectionInput.CollectionId) if err != nil { log.Error("Error in fetching active status") return core.NilHash, err @@ -98,13 +67,12 @@ func (*UtilsStruct) ModifyCollectionStatus(client *ethclient.Client, config type log.Errorf("Collection %d has the active status already set to %t", modifyCollectionInput.CollectionId, modifyCollectionInput.Status) return core.NilHash, nil } - _, err = cmdUtils.WaitForAppropriateState(client, "modify collection status", 4) + _, err = cmdUtils.WaitForAppropriateState(rpcParameters, "modify collection status", 4) if err != nil { return core.NilHash, err } txnArgs := types.TransactionOptions{ - Client: client, ChainId: core.ChainId, Config: config, ContractAddress: core.CollectionManagerAddress, @@ -114,8 +82,16 @@ func (*UtilsStruct) ModifyCollectionStatus(client *ethclient.Client, config type Account: modifyCollectionInput.Account, } - txnOpts := razorUtils.GetTxnOpts(txnArgs) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) + if err != nil { + return core.NilHash, err + } log.Infof("Changing active status of collection: %d from %t to %t", modifyCollectionInput.CollectionId, !modifyCollectionInput.Status, modifyCollectionInput.Status) + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debugf("Executing SetCollectionStatus transaction with status = %v, collectionId = %d", modifyCollectionInput.Status, modifyCollectionInput.CollectionId) txn, err := assetManagerUtils.SetCollectionStatus(client, txnOpts, modifyCollectionInput.Status, modifyCollectionInput.CollectionId) if err != nil { diff --git a/cmd/modifyCollectionStatus_test.go b/cmd/modifyCollectionStatus_test.go index f6fb0d750..f11ed4e3c 100644 --- a/cmd/modifyCollectionStatus_test.go +++ b/cmd/modifyCollectionStatus_test.go @@ -8,7 +8,6 @@ import ( "razor/core/types" "testing" - "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethclient" @@ -16,71 +15,8 @@ import ( "github.com/stretchr/testify/mock" ) -func TestCheckCurrentStatus(t *testing.T) { - - var client *ethclient.Client - var assetId uint16 - - type args struct { - callOpts bind.CallOpts - activeStatus bool - activeStatusErr error - } - tests := []struct { - name string - args args - want bool - wantErr error - }{ - { - name: "Test 1: When CheckCurrentStatus function executes successfully", - args: args{ - callOpts: bind.CallOpts{}, - activeStatus: true, - activeStatusErr: nil, - }, - want: true, - wantErr: nil, - }, - { - name: "Test 2: When GetActiveStatus function gives an error", - args: args{ - callOpts: bind.CallOpts{}, - activeStatusErr: errors.New("activeStatus error"), - }, - want: false, - wantErr: errors.New("activeStatus error"), - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - SetUpMockInterfaces() - - utilsMock.On("GetOptions").Return(tt.args.callOpts) - assetManagerMock.On("GetActiveStatus", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.AnythingOfType("uint16")).Return(tt.args.activeStatus, tt.args.activeStatusErr) - - utils := &UtilsStruct{} - got, err := utils.CheckCurrentStatus(client, assetId) - if got != tt.want { - t.Errorf("Status from CheckCurrentStatus function, got = %v, want %v", got, tt.want) - } - if err == nil || tt.wantErr == nil { - if err != tt.wantErr { - t.Errorf("Error for CheckCurrentStatus function, got = %v, want %v", err, tt.wantErr) - } - } else { - if err.Error() != tt.wantErr.Error() { - t.Errorf("Error for CheckCurrentStatus function, got = %v, want %v", err, tt.wantErr) - } - } - - }) - } -} - func TestModifyAssetStatus(t *testing.T) { var config types.Configurations - var client *ethclient.Client type args struct { status bool @@ -88,6 +24,7 @@ func TestModifyAssetStatus(t *testing.T) { currentStatusErr error epoch uint32 epochErr error + txnOptsErr error SetCollectionStatus *Types.Transaction SetAssetStatusErr error hash common.Hash @@ -155,20 +92,31 @@ func TestModifyAssetStatus(t *testing.T) { want: core.NilHash, wantErr: errors.New("WaitForAppropriateState error"), }, + { + name: "Test 6: When there is an error in getting txnOpts", + args: args{ + status: true, + currentStatus: false, + SetCollectionStatus: &Types.Transaction{}, + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - cmdUtilsMock.On("CheckCurrentStatus", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint16")).Return(tt.args.currentStatus, tt.args.currentStatusErr) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) - cmdUtilsMock.On("WaitForAppropriateState", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string"), mock.Anything).Return(tt.args.epoch, tt.args.epochErr) + utilsMock.On("GetActiveStatus", mock.Anything, mock.Anything).Return(tt.args.currentStatus, tt.args.currentStatusErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) + cmdUtilsMock.On("WaitForAppropriateState", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.epoch, tt.args.epochErr) assetManagerMock.On("SetCollectionStatus", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.SetCollectionStatus, tt.args.SetAssetStatusErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.ModifyCollectionStatus(client, config, types.ModifyCollectionInput{ + got, err := utils.ModifyCollectionStatus(rpcParameters, config, types.ModifyCollectionInput{ Status: tt.args.status, }) if got != tt.want { @@ -309,13 +257,16 @@ func TestExecuteModifyAssetStatus(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) flagSetMock.On("GetStringAddress", flagSet).Return(tt.args.address, tt.args.addressErr) @@ -327,7 +278,7 @@ func TestExecuteModifyAssetStatus(t *testing.T) { stringMock.On("ParseBool", mock.AnythingOfType("string")).Return(tt.args.parseStatus, tt.args.parseStatusErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) cmdUtilsMock.On("ModifyCollectionStatus", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.ModifyCollectionStatusHash, tt.args.ModifyCollectionStatusErr) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) utils := &UtilsStruct{} fatal = false diff --git a/cmd/propose.go b/cmd/propose.go index 43aa82655..03d5de70b 100644 --- a/cmd/propose.go +++ b/cmd/propose.go @@ -9,6 +9,7 @@ import ( "razor/core" "razor/core/types" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "sort" "strings" @@ -16,7 +17,6 @@ import ( "time" Types "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" solsha3 "github.com/miguelmota/go-solidity-sha3" ) @@ -31,12 +31,12 @@ var globalProposedDataStruct types.ProposeFileData // Find iteration using salt as seed //This functions handles the propose state -func (*UtilsStruct) Propose(client *ethclient.Client, config types.Configurations, account types.Account, staker bindings.StructsStaker, epoch uint32, latestHeader *Types.Header, rogueData types.Rogue) error { - if state, err := razorUtils.GetBufferedState(client, latestHeader, config.BufferPercent); err != nil || state != 2 { +func (*UtilsStruct) Propose(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, staker bindings.StructsStaker, epoch uint32, latestHeader *Types.Header, stateBuffer uint64, rogueData types.Rogue) error { + if state, err := razorUtils.GetBufferedState(latestHeader, stateBuffer, config.BufferPercent); err != nil || state != 2 { log.Error("Not propose state") return err } - numStakers, err := razorUtils.GetNumberOfStakers(client) + numStakers, err := razorUtils.GetNumberOfStakers(rpcParameters) if err != nil { log.Error("Error in fetching number of stakers: ", err) return err @@ -53,7 +53,7 @@ func (*UtilsStruct) Propose(client *ethclient.Client, config types.Configuration if rogueData.IsRogue && utils.Contains(rogueData.RogueMode, "biggestStakerId") { log.Warn("YOU ARE PROPOSING IN ROGUE MODE, THIS CAN INCUR PENALTIES!") // If staker is going rogue with biggestStakerId than we do biggestStakerId = smallestStakerId - smallestStake, smallestStakerId, smallestStakerErr := cmdUtils.GetSmallestStakeAndId(client, epoch) + smallestStake, smallestStakerId, smallestStakerErr := cmdUtils.GetSmallestStakeAndId(rpcParameters, epoch) if smallestStakerErr != nil { log.Error("Error in calculating smallest staker: ", smallestStakerErr) return smallestStakerErr @@ -62,7 +62,7 @@ func (*UtilsStruct) Propose(client *ethclient.Client, config types.Configuration biggestStakerId = smallestStakerId log.Debugf("Propose: In rogue mode, Biggest Stake: %s, Biggest Staker Id: %d", biggestStake, biggestStakerId) } else { - biggestStake, biggestStakerId, biggestStakerErr = cmdUtils.GetBiggestStakeAndId(client, epoch) + biggestStake, biggestStakerId, biggestStakerErr = cmdUtils.GetBiggestStakeAndId(rpcParameters, epoch) if biggestStakerErr != nil { log.Error("Error in calculating biggest staker: ", biggestStakerErr) return biggestStakerErr @@ -70,7 +70,7 @@ func (*UtilsStruct) Propose(client *ethclient.Client, config types.Configuration } log.Debugf("Getting Salt for current epoch %d...", epoch) - salt, err := cmdUtils.GetSalt(client, epoch) + salt, err := cmdUtils.GetSalt(rpcParameters, epoch) if err != nil { return err } @@ -85,20 +85,20 @@ func (*UtilsStruct) Propose(client *ethclient.Client, config types.Configuration Epoch: epoch, } log.Debugf("Propose: Calling GetIteration with arguments proposer = %+v, buffer percent = %d", proposer, config.BufferPercent) - iteration := cmdUtils.GetIteration(client, proposer, config.BufferPercent) + iteration := cmdUtils.GetIteration(rpcParameters, proposer, config.BufferPercent) log.Debug("Iteration: ", iteration) if iteration == -1 { return nil } - numOfProposedBlocks, err := razorUtils.GetNumberOfProposedBlocks(client, epoch) + numOfProposedBlocks, err := razorUtils.GetNumberOfProposedBlocks(rpcParameters, epoch) if err != nil { log.Error(err) return err } log.Debug("Propose: Number of proposed blocks: ", numOfProposedBlocks) - maxAltBlocks, err := razorUtils.GetMaxAltBlocks(client) + maxAltBlocks, err := razorUtils.GetMaxAltBlocks(rpcParameters) if err != nil { log.Error(err) return err @@ -107,15 +107,21 @@ func (*UtilsStruct) Propose(client *ethclient.Client, config types.Configuration if numOfProposedBlocks >= maxAltBlocks { log.Debugf("Number of blocks proposed: %d, which is equal or greater than maximum alternative blocks allowed", numOfProposedBlocks) log.Debug("Comparing iterations...") - sortedProposedBlocks, err := razorUtils.GetSortedProposedBlockIds(client, epoch) + sortedProposedBlocks, err := razorUtils.GetSortedProposedBlockIds(rpcParameters, epoch) if err != nil { log.Error("Error in fetching sorted proposed block ids") return err } log.Debug("Propose: Sorted proposed blocks: ", sortedProposedBlocks) + + if numOfProposedBlocks <= 0 || len(sortedProposedBlocks) < int(numOfProposedBlocks) { + log.Errorf("Invalid numOfProposedBlocks (%d) or mismatch with sortedProposedBlocks length (%d)", numOfProposedBlocks, len(sortedProposedBlocks)) + return errors.New("proposed blocks count mismatch") + } + lastBlockIndex := sortedProposedBlocks[numOfProposedBlocks-1] log.Debug("Propose: Last block index: ", lastBlockIndex) - lastProposedBlockStruct, err := razorUtils.GetProposedBlock(client, epoch, lastBlockIndex) + lastProposedBlockStruct, err := razorUtils.GetProposedBlock(rpcParameters, epoch, lastBlockIndex) if err != nil { log.Error(err) return err @@ -130,7 +136,7 @@ func (*UtilsStruct) Propose(client *ethclient.Client, config types.Configuration log.Info("Current iteration is less than iteration of last proposed block, can propose") } log.Debugf("Propose: Calling MakeBlock() with arguments blockNumber = %s, epoch = %d, rogueData = %+v", latestHeader.Number, epoch, rogueData) - medians, ids, revealedDataMaps, err := cmdUtils.MakeBlock(client, latestHeader.Number, epoch, rogueData) + medians, ids, revealedDataMaps, err := cmdUtils.MakeBlock(rpcParameters, latestHeader.Number, epoch, rogueData) if err != nil { log.Error(err) return err @@ -140,8 +146,7 @@ func (*UtilsStruct) Propose(client *ethclient.Client, config types.Configuration log.Debugf("Propose: Iteration: %d Biggest Staker Id: %d", iteration, biggestStakerId) log.Info("Proposing block...") - txnOpts := razorUtils.GetTxnOpts(types.TransactionOptions{ - Client: client, + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{ ChainId: core.ChainId, Config: config, ContractAddress: core.BlockManagerAddress, @@ -150,6 +155,15 @@ func (*UtilsStruct) Propose(client *ethclient.Client, config types.Configuration Parameters: []interface{}{epoch, ids, medians, big.NewInt(int64(iteration)), biggestStakerId}, Account: account, }) + if err != nil { + return err + } + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + log.Error(err) + return err + } log.Debugf("Executing Propose transaction with epoch = %d, Ids = %v, medians = %s, iteration = %s, biggestStakerId = %d", epoch, ids, medians, big.NewInt(int64(iteration)), biggestStakerId) txn, err := blockManagerUtils.Propose(client, txnOpts, epoch, ids, medians, big.NewInt(int64(iteration)), biggestStakerId) @@ -158,45 +172,39 @@ func (*UtilsStruct) Propose(client *ethclient.Client, config types.Configuration return err } proposeTxn := transactionUtils.Hash(txn) - log.Info("Txn Hash: ", proposeTxn.Hex()) + log.Info("Propose Transaction Hash: ", proposeTxn.Hex()) if proposeTxn != core.NilHash { - waitForBlockCompletionErr := razorUtils.WaitForBlockCompletion(client, proposeTxn.Hex()) - if waitForBlockCompletionErr != nil { - log.Error("Error in WaitForBlockCompletionErr for propose: ", waitForBlockCompletionErr) - return waitForBlockCompletionErr - } else { - // Saving proposed data after successful propose - log.Debug("Updating global propose data struct...") - updateGlobalProposedDataStruct(types.ProposeFileData{ - MediansData: medians, - RevealedDataMaps: revealedDataMaps, - RevealedCollectionIds: ids, - Epoch: epoch, - }) - log.Debugf("Propose: Global propose data struct: %+v", globalProposedDataStruct) - - log.Debug("Saving proposed data for recovery...") - fileName, err := pathUtils.GetProposeDataFileName(account.Address) - if err != nil { - log.Error("Error in getting file name to save median data: ", err) - return err - } - log.Debug("Propose: Propose data file path: ", fileName) - err = fileUtils.SaveDataToProposeJsonFile(fileName, globalProposedDataStruct) - if err != nil { - log.Errorf("Error in saving data to file %s: %v", fileName, err) - return err - } - log.Debug("Data saved!") + // Saving proposed data after getting the transaction hash + log.Debug("Updating global propose data struct...") + updateGlobalProposedDataStruct(types.ProposeFileData{ + MediansData: medians, + RevealedDataMaps: revealedDataMaps, + RevealedCollectionIds: ids, + Epoch: epoch, + }) + log.Debugf("Propose: Global propose data struct: %+v", globalProposedDataStruct) + + log.Debug("Saving proposed data for recovery...") + fileName, err := pathUtils.GetProposeDataFileName(account.Address) + if err != nil { + log.Error("Error in getting file name to save median data: ", err) + return err + } + log.Debug("Propose: Propose data file path: ", fileName) + err = fileUtils.SaveDataToProposeJsonFile(fileName, globalProposedDataStruct) + if err != nil { + log.Errorf("Error in saving data to file %s: %v", fileName, err) + return err } + log.Debug("Data saved!") } return nil } //This function returns the biggest stake and Id of it -func (*UtilsStruct) GetBiggestStakeAndId(client *ethclient.Client, epoch uint32) (*big.Int, uint32, error) { - numberOfStakers, err := razorUtils.GetNumberOfStakers(client) +func (*UtilsStruct) GetBiggestStakeAndId(rpcParameters rpc.RPCParameters, epoch uint32) (*big.Int, uint32, error) { + numberOfStakers, err := razorUtils.GetNumberOfStakers(rpcParameters) if err != nil { return nil, 0, err } @@ -207,7 +215,7 @@ func (*UtilsStruct) GetBiggestStakeAndId(client *ethclient.Client, epoch uint32) var biggestStakerId uint32 biggestStake := big.NewInt(0) - stakeSnapshotArray, err := cmdUtils.BatchGetStakeSnapshotCalls(client, epoch, numberOfStakers) + stakeSnapshotArray, err := cmdUtils.BatchGetStakeSnapshotCalls(rpcParameters, epoch, numberOfStakers) if err != nil { return nil, 0, err } @@ -230,15 +238,25 @@ func (*UtilsStruct) GetBiggestStakeAndId(client *ethclient.Client, epoch uint32) return biggestStake, biggestStakerId, nil } -func (*UtilsStruct) GetIteration(client *ethclient.Client, proposer types.ElectedProposer, bufferPercent int32) int { - stake, err := razorUtils.GetStakeSnapshot(client, proposer.StakerId, proposer.Epoch) +func (*UtilsStruct) GetIteration(rpcParameters rpc.RPCParameters, proposer types.ElectedProposer, bufferPercent int32) int { + stake, err := razorUtils.GetStakeSnapshot(rpcParameters, proposer.StakerId, proposer.Epoch) if err != nil { log.Error("Error in fetching influence of staker: ", err) return -1 } log.Debug("GetIteration: Stake: ", stake) currentStakerStake := big.NewInt(1).Mul(stake, big.NewInt(int64(math.Exp2(32)))) - stateRemainingTime, err := razorUtils.GetRemainingTimeOfCurrentState(client, bufferPercent) + stateBuffer, err := razorUtils.GetStateBuffer(rpcParameters) + if err != nil { + log.Error("Error in getting state buffer: ", err) + return -1 + } + latestHeader, err := clientUtils.GetLatestBlockWithRetry(rpcParameters) + if err != nil { + log.Error("Error in getting latest block: ", err) + return -1 + } + stateRemainingTime, err := razorUtils.GetRemainingTimeOfCurrentState(latestHeader, stateBuffer, bufferPercent) if err != nil { return -1 } @@ -340,9 +358,9 @@ func pseudoRandomNumberGenerator(seed []byte, max uint32, blockHashes []byte) *b } //This function returns the sorted revealed values -func (*UtilsStruct) GetSortedRevealedValues(client *ethclient.Client, blockNumber *big.Int, epoch uint32) (*types.RevealedDataMaps, error) { +func (*UtilsStruct) GetSortedRevealedValues(rpcParameters rpc.RPCParameters, blockNumber *big.Int, epoch uint32) (*types.RevealedDataMaps, error) { log.Debugf("GetSortedRevealedValues: Calling IndexRevealEventsOfCurrentEpoch with arguments blockNumber = %s, epoch = %d", blockNumber, epoch) - assignedAsset, err := cmdUtils.IndexRevealEventsOfCurrentEpoch(client, blockNumber, epoch) + assignedAsset, err := cmdUtils.IndexRevealEventsOfCurrentEpoch(rpcParameters, blockNumber, epoch) if err != nil { return nil, err } @@ -387,15 +405,15 @@ func (*UtilsStruct) GetSortedRevealedValues(client *ethclient.Client, blockNumbe } //This function returns the medians, idsRevealedInThisEpoch and revealedDataMaps -func (*UtilsStruct) MakeBlock(client *ethclient.Client, blockNumber *big.Int, epoch uint32, rogueData types.Rogue) ([]*big.Int, []uint16, *types.RevealedDataMaps, error) { +func (*UtilsStruct) MakeBlock(rpcParameters rpc.RPCParameters, blockNumber *big.Int, epoch uint32, rogueData types.Rogue) ([]*big.Int, []uint16, *types.RevealedDataMaps, error) { log.Debugf("MakeBlock: Calling GetSortedRevealedValues with arguments blockNumber = %s, epoch = %d", blockNumber, epoch) - revealedDataMaps, err := cmdUtils.GetSortedRevealedValues(client, blockNumber, epoch) + revealedDataMaps, err := cmdUtils.GetSortedRevealedValues(rpcParameters, blockNumber, epoch) if err != nil { return nil, nil, nil, err } log.Debugf("MakeBlock: Revealed data map: %+v", revealedDataMaps) - activeCollections, err := razorUtils.GetActiveCollectionIds(client) + activeCollections, err := razorUtils.GetActiveCollectionIds(rpcParameters) if err != nil { return nil, nil, nil, err } @@ -447,8 +465,8 @@ func (*UtilsStruct) MakeBlock(client *ethclient.Client, blockNumber *big.Int, ep return medians, idsRevealedInThisEpoch, revealedDataMaps, nil } -func (*UtilsStruct) GetSmallestStakeAndId(client *ethclient.Client, epoch uint32) (*big.Int, uint32, error) { - numberOfStakers, err := razorUtils.GetNumberOfStakers(client) +func (*UtilsStruct) GetSmallestStakeAndId(rpcParameters rpc.RPCParameters, epoch uint32) (*big.Int, uint32, error) { + numberOfStakers, err := razorUtils.GetNumberOfStakers(rpcParameters) if err != nil { return nil, 0, err } @@ -459,7 +477,7 @@ func (*UtilsStruct) GetSmallestStakeAndId(client *ethclient.Client, epoch uint32 smallestStake := big.NewInt(1).Mul(big.NewInt(1e18), big.NewInt(1e18)) for i := 1; i <= int(numberOfStakers); i++ { - stake, err := razorUtils.GetStakeSnapshot(client, uint32(i), epoch) + stake, err := razorUtils.GetStakeSnapshot(rpcParameters, uint32(i), epoch) if err != nil { return nil, 0, err } @@ -471,7 +489,7 @@ func (*UtilsStruct) GetSmallestStakeAndId(client *ethclient.Client, epoch uint32 return smallestStake, smallestStakerId, nil } -func (*UtilsStruct) BatchGetStakeSnapshotCalls(client *ethclient.Client, epoch uint32, numberOfStakers uint32) ([]*big.Int, error) { +func (*UtilsStruct) BatchGetStakeSnapshotCalls(rpcParameters rpc.RPCParameters, epoch uint32, numberOfStakers uint32) ([]*big.Int, error) { voteManagerABI, err := utils.ABIInterface.Parse(strings.NewReader(bindings.VoteManagerMetaData.ABI)) if err != nil { log.Errorf("Error in parsed voteManager ABI: %v", err) @@ -483,7 +501,7 @@ func (*UtilsStruct) BatchGetStakeSnapshotCalls(client *ethclient.Client, epoch u args[i-1] = []interface{}{epoch, i} } - results, err := clientUtils.BatchCall(client, &voteManagerABI, core.VoteManagerAddress, core.GetStakeSnapshotMethod, args) + results, err := clientUtils.BatchCall(rpcParameters, &voteManagerABI, core.VoteManagerAddress, core.GetStakeSnapshotMethod, args) if err != nil { log.Error("Error in performing getStakeSnapshot batch calls: ", err) return nil, err diff --git a/cmd/propose_test.go b/cmd/propose_test.go index 6ab69727a..c94c84191 100644 --- a/cmd/propose_test.go +++ b/cmd/propose_test.go @@ -8,7 +8,6 @@ import ( "math/big" "razor/core/types" "razor/pkg/bindings" - utilsPkgMocks "razor/utils/mocks" "reflect" "strings" "testing" @@ -17,17 +16,16 @@ import ( "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" ) func TestPropose(t *testing.T) { var ( - client *ethclient.Client - account types.Account - config types.Configurations - staker bindings.StructsStaker - epoch uint32 + account types.Account + config types.Configurations + staker bindings.StructsStaker + epoch uint32 + stateBuffer uint64 ) salt := []byte{142, 170, 157, 83, 109, 43, 34, 152, 21, 154, 159, 12, 195, 119, 50, 186, 218, 57, 39, 173, 228, 135, 20, 100, 149, 27, 169, 158, 34, 113, 66, 64} @@ -72,10 +70,10 @@ func TestPropose(t *testing.T) { fileNameErr error saveDataErr error mediansBigInt []*big.Int + txnOptsErr error proposeTxn *Types.Transaction proposeErr error hash common.Hash - waitForBlockCompletionErr error } tests := []struct { name string @@ -480,56 +478,68 @@ func TestPropose(t *testing.T) { wantErr: errors.New("smallestStakerId error"), }, { - name: "Test 19: When there is an error in waitForCompletion", + name: "Test 19: When there is an error in getting txnOpts", args: args{ - state: 2, - staker: bindings.StructsStaker{}, - numStakers: 5, - biggestStake: big.NewInt(1).Mul(big.NewInt(5356), big.NewInt(1e18)), - biggestStakerId: 2, - salt: saltBytes32, - iteration: 1, - numOfProposedBlocks: 3, - sortedProposedBlockIds: []uint32{2, 0, 1}, - maxAltBlocks: 4, - lastIteration: big.NewInt(5), - lastProposedBlockStruct: bindings.StructsBlock{}, - medians: []*big.Int{big.NewInt(6701548), big.NewInt(478307)}, - proposeTxn: &Types.Transaction{}, - hash: common.BigToHash(big.NewInt(1)), - waitForBlockCompletionErr: errors.New("waitForBlockCompletion error"), + state: 2, + staker: bindings.StructsStaker{}, + numStakers: 5, + biggestStake: big.NewInt(1).Mul(big.NewInt(5356), big.NewInt(1e18)), + biggestStakerId: 2, + salt: saltBytes32, + iteration: 1, + numOfProposedBlocks: 3, + sortedProposedBlockIds: []uint32{2, 1, 0}, + maxAltBlocks: 4, + lastIteration: big.NewInt(5), + lastProposedBlockStruct: bindings.StructsBlock{}, + medians: []*big.Int{big.NewInt(6701548), big.NewInt(478307)}, + txnOptsErr: errors.New("txnOpts error"), }, - wantErr: errors.New("waitForBlockCompletion error"), + wantErr: errors.New("txnOpts error"), + }, + { + name: "Test 20: When there is a mismatch in number of proposed blocks and length of sorted proposed blocks array", + args: args{ + state: 2, + staker: bindings.StructsStaker{}, + numStakers: 5, + biggestStake: big.NewInt(1).Mul(big.NewInt(5356), big.NewInt(1e18)), + biggestStakerId: 2, + salt: saltBytes32, + iteration: 1, + numOfProposedBlocks: 3, + sortedProposedBlockIds: []uint32{2, 1}, + }, + wantErr: errors.New("proposed blocks count mismatch"), }, } for _, tt := range tests { SetUpMockInterfaces() utilsMock.On("GetBufferedState", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.state, tt.args.stateErr) - utilsMock.On("GetNumberOfStakers", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.numStakers, tt.args.numStakerErr) - cmdUtilsMock.On("GetBiggestStakeAndId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.biggestStake, tt.args.biggestStakerId, tt.args.biggestStakerIdErr) + utilsMock.On("GetNumberOfStakers", mock.Anything).Return(tt.args.numStakers, tt.args.numStakerErr) + cmdUtilsMock.On("GetBiggestStakeAndId", mock.Anything, mock.Anything).Return(tt.args.biggestStake, tt.args.biggestStakerId, tt.args.biggestStakerIdErr) cmdUtilsMock.On("GetSmallestStakeAndId", mock.Anything, mock.Anything).Return(tt.args.smallestStake, tt.args.smallestStakerId, tt.args.smallestStakerIdErr) utilsMock.On("GetRandaoHash", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.randaoHash, tt.args.randaoHashErr) cmdUtilsMock.On("GetIteration", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.iteration) - utilsMock.On("GetMaxAltBlocks", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.maxAltBlocks, tt.args.maxAltBlocksErr) - cmdUtilsMock.On("GetSalt", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.salt, tt.args.saltErr) - cmdUtilsMock.On("GetIteration", mock.Anything, mock.Anything).Return(tt.args.iteration) - utilsMock.On("GetNumberOfProposedBlocks", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.numOfProposedBlocks, tt.args.numOfProposedBlocksErr) - utilsMock.On("GetSortedProposedBlockIds", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.sortedProposedBlockIds, tt.args.sortedProposedBlocksIdsErr) - utilsMock.On("GetMaxAltBlocks", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.maxAltBlocks, tt.args.maxAltBlocksErr) - utilsMock.On("GetProposedBlock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(tt.args.lastProposedBlockStruct, tt.args.lastProposedBlockStructErr) - cmdUtilsMock.On("MakeBlock", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything).Return(tt.args.medians, tt.args.ids, tt.args.revealDataMaps, tt.args.mediansErr) + utilsMock.On("GetMaxAltBlocks", mock.Anything).Return(tt.args.maxAltBlocks, tt.args.maxAltBlocksErr) + cmdUtilsMock.On("GetSalt", mock.Anything, mock.Anything).Return(tt.args.salt, tt.args.saltErr) + cmdUtilsMock.On("GetIteration", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.iteration) + utilsMock.On("GetNumberOfProposedBlocks", mock.Anything, mock.Anything).Return(tt.args.numOfProposedBlocks, tt.args.numOfProposedBlocksErr) + utilsMock.On("GetSortedProposedBlockIds", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.sortedProposedBlockIds, tt.args.sortedProposedBlocksIdsErr) + utilsMock.On("GetMaxAltBlocks", mock.Anything).Return(tt.args.maxAltBlocks, tt.args.maxAltBlocksErr) + utilsMock.On("GetProposedBlock", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.lastProposedBlockStruct, tt.args.lastProposedBlockStructErr) + cmdUtilsMock.On("MakeBlock", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.medians, tt.args.ids, tt.args.revealDataMaps, tt.args.mediansErr) utilsMock.On("ConvertUint32ArrayToBigIntArray", mock.Anything).Return(tt.args.mediansBigInt) pathMock.On("GetProposeDataFileName", mock.AnythingOfType("string")).Return(tt.args.fileName, tt.args.fileNameErr) fileUtilsMock.On("SaveDataToProposeJsonFile", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.saveDataErr) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) blockManagerMock.On("Propose", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.proposeTxn, tt.args.proposeErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.waitForBlockCompletionErr) utils := &UtilsStruct{} t.Run(tt.name, func(t *testing.T) { - err := utils.Propose(client, config, account, staker, epoch, latestHeader, tt.args.rogueData) + err := utils.Propose(rpcParameters, config, account, staker, epoch, latestHeader, stateBuffer, tt.args.rogueData) if err == nil || tt.wantErr == nil { if err != tt.wantErr { t.Errorf("Error for Propose function, got = %v, want %v", err, tt.wantErr) @@ -544,7 +554,6 @@ func TestPropose(t *testing.T) { } func TestGetBiggestStakeAndId(t *testing.T) { - var client *ethclient.Client var epoch uint32 type args struct { @@ -613,12 +622,12 @@ func TestGetBiggestStakeAndId(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetNumberOfStakers", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.numOfStakers, tt.args.numOfStakersErr) - cmdUtilsMock.On("BatchGetStakeSnapshotCalls", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(tt.args.stakeArray, tt.args.stakeErr) + utilsMock.On("GetNumberOfStakers", mock.Anything).Return(tt.args.numOfStakers, tt.args.numOfStakersErr) + cmdUtilsMock.On("BatchGetStakeSnapshotCalls", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.stakeArray, tt.args.stakeErr) utils := &UtilsStruct{} - gotStake, gotId, err := utils.GetBiggestStakeAndId(client, epoch) + gotStake, gotId, err := utils.GetBiggestStakeAndId(rpcParameters, epoch) if err == nil || tt.wantErr == nil { if err != tt.wantErr { t.Errorf("Error for GetBiggestStakeAndId function, got = %v, want %v", err, tt.wantErr) @@ -645,7 +654,6 @@ func stakeSnapshotValue(stake string) *big.Int { } func TestGetIteration(t *testing.T) { - var client *ethclient.Client var bufferPercent int32 salt := []byte{142, 170, 157, 83, 109, 43, 34, 152, 21, 154, 159, 12, 195, 119, 50, 186, 218, 57, 39, 173, 228, 135, 20, 100, 149, 27, 169, 158, 34, 113, 66, 64} @@ -662,6 +670,10 @@ func TestGetIteration(t *testing.T) { type args struct { stakeSnapshot *big.Int stakeSnapshotErr error + stateBuffer uint64 + stateBufferErr error + latestHeader *Types.Header + latestHeaderErr error remainingTime int64 remainingTimeErr error } @@ -674,6 +686,8 @@ func TestGetIteration(t *testing.T) { name: "Test 1: When getIteration returns a valid iteration", args: args{ stakeSnapshot: big.NewInt(1000), + stateBuffer: 5, + latestHeader: &Types.Header{}, remainingTime: 10, }, want: 70183, @@ -682,6 +696,7 @@ func TestGetIteration(t *testing.T) { name: "Test 2: When there is an error in getting stakeSnapshotValue", args: args{ stakeSnapshot: big.NewInt(0), + latestHeader: &Types.Header{}, stakeSnapshotErr: errors.New("error in getting stakeSnapshotValue"), }, want: -1, @@ -690,6 +705,8 @@ func TestGetIteration(t *testing.T) { name: "Test 3: When getIteration returns an invalid iteration", args: args{ stakeSnapshot: big.NewInt(1), + stateBuffer: 5, + latestHeader: &Types.Header{}, remainingTime: 2, }, want: -1, @@ -698,23 +715,41 @@ func TestGetIteration(t *testing.T) { name: "Test 4: When there is an error in getting remaining time for the state", args: args{ stakeSnapshot: stakeSnapshotValue("2592145500000000000000000"), + stateBuffer: 5, + latestHeader: &Types.Header{}, remainingTimeErr: errors.New("remaining time error"), }, want: -1, }, + { + name: "Test 5: When there is an error in getting state buffer", + args: args{ + stakeSnapshot: big.NewInt(1000), + stateBufferErr: errors.New("state buffer error"), + }, + want: -1, + }, + { + name: "Test 6: When there is an error in getting latest header", + args: args{ + stakeSnapshot: big.NewInt(1000), + stateBuffer: 5, + latestHeaderErr: errors.New("latest header error"), + }, + want: -1, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - utilsMock = new(utilsPkgMocks.Utils) - razorUtils = utilsMock - + SetUpMockInterfaces() cmdUtils = &UtilsStruct{} - utilsMock.On("GetStakeSnapshot", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(big.NewInt(1).Mul(tt.args.stakeSnapshot, big.NewInt(1e18)), tt.args.stakeSnapshotErr) - utilsMock.On("GetRemainingTimeOfCurrentState", mock.Anything, mock.Anything).Return(tt.args.remainingTime, tt.args.remainingTimeErr) - - if got := cmdUtils.GetIteration(client, proposer, bufferPercent); got != tt.want { + utilsMock.On("GetStakeSnapshot", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(big.NewInt(1).Mul(tt.args.stakeSnapshot, big.NewInt(1e18)), tt.args.stakeSnapshotErr) + utilsMock.On("GetRemainingTimeOfCurrentState", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.remainingTime, tt.args.remainingTimeErr) + utilsMock.On("GetStateBuffer", mock.Anything).Return(tt.args.stateBuffer, tt.args.stateBufferErr) + clientUtilsMock.On("GetLatestBlockWithRetry", mock.Anything, mock.Anything).Return(tt.args.latestHeader, tt.args.latestHeaderErr) + if got := cmdUtils.GetIteration(rpcParameters, proposer, bufferPercent); got != tt.want { t.Errorf("getIteration() = %v, want %v", got, tt.want) } }) @@ -878,7 +913,6 @@ func Test_pseudoRandomNumberGenerator(t *testing.T) { func TestMakeBlock(t *testing.T) { var ( - client *ethclient.Client blockNumber *big.Int epoch uint32 ) @@ -1014,11 +1048,11 @@ func TestMakeBlock(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - cmdUtilsMock.On("GetSortedRevealedValues", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.revealedDataMaps, tt.args.revealedDataMapsErr) - utilsMock.On("GetActiveCollectionIds", mock.Anything).Return(tt.args.activeCollections, tt.args.activeCollectionsErr) + cmdUtilsMock.On("GetSortedRevealedValues", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.revealedDataMaps, tt.args.revealedDataMapsErr) + utilsMock.On("GetActiveCollectionIds", mock.Anything, mock.Anything).Return(tt.args.activeCollections, tt.args.activeCollectionsErr) utilsMock.On("GetRogueRandomValue", mock.Anything).Return(randomValue) ut := &UtilsStruct{} - got, got1, got2, err := ut.MakeBlock(client, blockNumber, epoch, tt.args.rogueData) + got, got1, got2, err := ut.MakeBlock(rpcParameters, blockNumber, epoch, tt.args.rogueData) if (err != nil) != tt.wantErr { t.Errorf("MakeBlock() error = %v, wantErr %v", err, tt.wantErr) return @@ -1038,7 +1072,6 @@ func TestMakeBlock(t *testing.T) { func TestGetSortedRevealedValues(t *testing.T) { var ( - client *ethclient.Client blockNumber *big.Int epoch uint32 ) @@ -1206,9 +1239,9 @@ func TestGetSortedRevealedValues(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - cmdUtilsMock.On("IndexRevealEventsOfCurrentEpoch", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.assignedAssets, tt.args.assignedAssetsErr) + cmdUtilsMock.On("IndexRevealEventsOfCurrentEpoch", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.assignedAssets, tt.args.assignedAssetsErr) ut := &UtilsStruct{} - got, err := ut.GetSortedRevealedValues(client, blockNumber, epoch) + got, err := ut.GetSortedRevealedValues(rpcParameters, blockNumber, epoch) if (err != nil) != tt.wantErr { t.Errorf("GetSortedRevealedValues() error = %v, wantErr %v", err, tt.wantErr) return @@ -1221,7 +1254,6 @@ func TestGetSortedRevealedValues(t *testing.T) { } func TestGetSmallestStakeAndId(t *testing.T) { - var client *ethclient.Client var epoch uint32 type args struct { @@ -1281,12 +1313,12 @@ func TestGetSmallestStakeAndId(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetNumberOfStakers", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.numOfStakers, tt.args.numOfStakersErr) - utilsMock.On("GetStakeSnapshot", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(tt.args.stake, tt.args.stakeErr) + utilsMock.On("GetNumberOfStakers", mock.Anything).Return(tt.args.numOfStakers, tt.args.numOfStakersErr) + utilsMock.On("GetStakeSnapshot", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.stake, tt.args.stakeErr) utils := &UtilsStruct{} - gotStake, gotId, err := utils.GetSmallestStakeAndId(client, epoch) + gotStake, gotId, err := utils.GetSmallestStakeAndId(rpcParameters, epoch) if gotStake.Cmp(tt.wantStake) != 0 { t.Errorf("Smallest Stake from GetSmallestStakeAndId function, got = %v, want %v", gotStake, tt.wantStake) } @@ -1308,7 +1340,6 @@ func TestGetSmallestStakeAndId(t *testing.T) { } func TestBatchGetStakeCalls(t *testing.T) { - var client *ethclient.Client var epoch uint32 voteManagerABI, _ := abi.JSON(strings.NewReader(bindings.VoteManagerMetaData.ABI)) @@ -1360,7 +1391,7 @@ func TestBatchGetStakeCalls(t *testing.T) { clientUtilsMock.On("BatchCall", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.batchCallResults, tt.args.batchCallError) ut := &UtilsStruct{} - gotStakes, err := ut.BatchGetStakeSnapshotCalls(client, epoch, tt.args.numberOfStakers) + gotStakes, err := ut.BatchGetStakeSnapshotCalls(rpcParameters, epoch, tt.args.numberOfStakers) if err == nil || tt.wantErr == nil { assert.Equal(t, tt.wantErr, err) @@ -1374,7 +1405,6 @@ func TestBatchGetStakeCalls(t *testing.T) { } func BenchmarkGetIteration(b *testing.B) { - var client *ethclient.Client var bufferPercent int32 salt := []byte{142, 170, 157, 83, 109, 43, 34, 152, 21, 154, 159, 12, 195, 119, 50, 186, 218, 57, 39, 173, 228, 135, 20, 100, 149, 27, 169, 158, 34, 113, 66, 64} @@ -1405,17 +1435,18 @@ func BenchmarkGetIteration(b *testing.B) { cmdUtils = &UtilsStruct{} - utilsMock.On("GetStakeSnapshot", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(big.NewInt(1).Mul(v.stakeSnapshot, big.NewInt(1e18)), nil) - utilsMock.On("GetRemainingTimeOfCurrentState", mock.Anything, mock.Anything).Return(int64(100), nil) + utilsMock.On("GetStakeSnapshot", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(big.NewInt(1).Mul(v.stakeSnapshot, big.NewInt(1e18)), nil) + utilsMock.On("GetRemainingTimeOfCurrentState", mock.Anything, mock.Anything, mock.Anything).Return(int64(100), nil) + utilsMock.On("GetStateBuffer", mock.Anything).Return(uint64(5), nil) + clientUtilsMock.On("GetLatestBlockWithRetry", mock.Anything, mock.Anything).Return(&Types.Header{}, nil) - cmdUtils.GetIteration(client, proposer, bufferPercent) + cmdUtils.GetIteration(rpcParameters, proposer, bufferPercent) } }) } } func BenchmarkGetBiggestStakeAndId(b *testing.B) { - var client *ethclient.Client var epoch uint32 var table = []struct { @@ -1432,11 +1463,11 @@ func BenchmarkGetBiggestStakeAndId(b *testing.B) { for i := 0; i < b.N; i++ { SetUpMockInterfaces() - utilsMock.On("GetNumberOfStakers", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(v.numOfStakers, nil) + utilsMock.On("GetNumberOfStakers", mock.Anything).Return(v.numOfStakers, nil) cmdUtilsMock.On("BatchGetStakeSnapshotCalls", mock.Anything, mock.Anything, mock.Anything).Return(GenerateDummyStakeSnapshotArray(v.numOfStakers), nil) ut := &UtilsStruct{} - _, _, err := ut.GetBiggestStakeAndId(client, epoch) + _, _, err := ut.GetBiggestStakeAndId(rpcParameters, epoch) if err != nil { log.Fatal(err) } @@ -1447,7 +1478,6 @@ func BenchmarkGetBiggestStakeAndId(b *testing.B) { func BenchmarkGetSortedRevealedValues(b *testing.B) { var ( - client *ethclient.Client blockNumber *big.Int epoch uint32 ) @@ -1467,9 +1497,9 @@ func BenchmarkGetSortedRevealedValues(b *testing.B) { asset := GetDummyRevealedValues(v.numOfRevealedValues) - cmdUtilsMock.On("IndexRevealEventsOfCurrentEpoch", mock.Anything, mock.Anything, mock.Anything).Return(GetDummyAssignedAssets(asset, v.numOfAssignedAssets), nil) + cmdUtilsMock.On("IndexRevealEventsOfCurrentEpoch", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(GetDummyAssignedAssets(asset, v.numOfAssignedAssets), nil) ut := &UtilsStruct{} - _, err := ut.GetSortedRevealedValues(client, blockNumber, epoch) + _, err := ut.GetSortedRevealedValues(rpcParameters, blockNumber, epoch) if err != nil { log.Fatal(err) } @@ -1480,7 +1510,6 @@ func BenchmarkGetSortedRevealedValues(b *testing.B) { func BenchmarkMakeBlock(b *testing.B) { var ( - client *ethclient.Client blockNumber *big.Int epoch uint32 ) @@ -1501,14 +1530,14 @@ func BenchmarkMakeBlock(b *testing.B) { votes := GetDummyVotes(v.numOfVotes) - cmdUtilsMock.On("GetSortedRevealedValues", mock.Anything, mock.Anything, mock.Anything).Return(&types.RevealedDataMaps{ + cmdUtilsMock.On("GetSortedRevealedValues", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(&types.RevealedDataMaps{ SortedRevealedValues: map[uint16][]*big.Int{0: votes}, VoteWeights: map[string]*big.Int{(big.NewInt(1).Mul(big.NewInt(697718000), big.NewInt(1e18))).String(): big.NewInt(100)}, InfluenceSum: map[uint16]*big.Int{0: big.NewInt(100)}, }, nil) - utilsMock.On("GetActiveCollectionIds", mock.Anything).Return([]uint16{1}, nil) + utilsMock.On("GetActiveCollectionIds", mock.Anything, mock.Anything).Return([]uint16{1}, nil) ut := &UtilsStruct{} - _, _, _, err := ut.MakeBlock(client, blockNumber, epoch, types.Rogue{IsRogue: false}) + _, _, _, err := ut.MakeBlock(rpcParameters, blockNumber, epoch, types.Rogue{IsRogue: false}) if err != nil { log.Fatal(err) } diff --git a/cmd/resetUnstakeLock.go b/cmd/resetUnstakeLock.go index 3f4d5d474..c71f58299 100644 --- a/cmd/resetUnstakeLock.go +++ b/cmd/resetUnstakeLock.go @@ -2,15 +2,13 @@ package cmd import ( - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/pflag" "github.com/spf13/cobra" @@ -34,32 +32,10 @@ func initialiseExtendLock(cmd *cobra.Command, args []string) { //This function sets the flags appropriately and executes the ResetUnstakeLock function func (*UtilsStruct) ExecuteExtendLock(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteExtendLock: Config: %+v", config) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) - - stakerId, err := razorUtils.AssignStakerId(flagSet, client, address) + stakerId, err := razorUtils.AssignStakerId(rpcParameters, flagSet, account.Address) utils.CheckError("Error in getting stakerId: ", err) extendLockInput := types.ExtendLockInput{ @@ -67,16 +43,15 @@ func (*UtilsStruct) ExecuteExtendLock(flagSet *pflag.FlagSet) { Account: account, } - txn, err := cmdUtils.ResetUnstakeLock(client, config, extendLockInput) + txn, err := cmdUtils.ResetUnstakeLock(rpcParameters, config, extendLockInput) utils.CheckError("Error in extending lock: ", err) - err = razorUtils.WaitForBlockCompletion(client, txn.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txn.Hex()) utils.CheckError("Error in WaitForBlockCompletion for resetUnstakeLock: ", err) } //This function is used to reset the lock once the withdraw lock period is over -func (*UtilsStruct) ResetUnstakeLock(client *ethclient.Client, config types.Configurations, extendLockInput types.ExtendLockInput) (common.Hash, error) { - txnOpts := razorUtils.GetTxnOpts(types.TransactionOptions{ - Client: client, +func (*UtilsStruct) ResetUnstakeLock(rpcParameters rpc.RPCParameters, config types.Configurations, extendLockInput types.ExtendLockInput) (common.Hash, error) { + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{ ChainId: core.ChainId, Config: config, ContractAddress: core.StakeManagerAddress, @@ -85,8 +60,16 @@ func (*UtilsStruct) ResetUnstakeLock(client *ethclient.Client, config types.Conf ABI: bindings.StakeManagerMetaData.ABI, Account: extendLockInput.Account, }) + if err != nil { + return core.NilHash, err + } log.Info("Extending lock...") + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debug("Executing ResetUnstakeLock transaction with stakerId = ", extendLockInput.StakerId) txn, err := stakeManagerUtils.ResetUnstakeLock(client, txnOpts, extendLockInput.StakerId) if err != nil { diff --git a/cmd/resetUnstakeLock_test.go b/cmd/resetUnstakeLock_test.go index 1d598abdc..8119f5c08 100644 --- a/cmd/resetUnstakeLock_test.go +++ b/cmd/resetUnstakeLock_test.go @@ -18,9 +18,9 @@ import ( func TestExtendLock(t *testing.T) { var extendLockInput types.ExtendLockInput var config types.Configurations - var client *ethclient.Client type args struct { + txnOptsErr error resetLockTxn *Types.Transaction resetLockErr error hash common.Hash @@ -51,18 +51,26 @@ func TestExtendLock(t *testing.T) { want: core.NilHash, wantErr: errors.New("resetLock error"), }, + { + name: "Test 3: When there is an error in getting txnOpts", + args: args{ + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) stakeManagerMock.On("ResetUnstakeLock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.TransactOpts"), mock.AnythingOfType("uint32")).Return(tt.args.resetLockTxn, tt.args.resetLockErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.ResetUnstakeLock(client, config, extendLockInput) + got, err := utils.ResetUnstakeLock(rpcParameters, config, extendLockInput) if got != tt.want { t.Errorf("Txn hash for resetLock function, got = %v, want = %v", got, tt.want) } @@ -162,24 +170,26 @@ func TestExecuteExtendLock(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("AssignPassword", flagSet).Return(tt.args.password) utilsMock.On("CheckPassword", mock.Anything).Return(nil) utilsMock.On("AccountManagerForKeystore").Return(&accounts.AccountManager{}, nil) flagSetMock.On("GetStringAddress", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.address, tt.args.addressErr) - utilsMock.On("AssignStakerId", flagSet, mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) + utilsMock.On("AssignStakerId", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) - cmdUtilsMock.On("ResetUnstakeLock", mock.AnythingOfType("*ethclient.Client"), config, mock.Anything).Return(tt.args.resetLockTxn, tt.args.resetLockErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) + cmdUtilsMock.On("ResetUnstakeLock", mock.Anything, config, mock.Anything).Return(tt.args.resetLockTxn, tt.args.resetLockErr) utils := &UtilsStruct{} fatal = false diff --git a/cmd/reveal.go b/cmd/reveal.go index 0667c6666..1cd9423d6 100644 --- a/cmd/reveal.go +++ b/cmd/reveal.go @@ -7,18 +7,18 @@ import ( "razor/core" "razor/core/types" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "strings" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" ) //This function checks for epoch last committed -func (*UtilsStruct) CheckForLastCommitted(client *ethclient.Client, staker bindings.StructsStaker, epoch uint32) error { - epochLastCommitted, err := razorUtils.GetEpochLastCommitted(client, staker.Id) +func (*UtilsStruct) CheckForLastCommitted(rpcParameters rpc.RPCParameters, staker bindings.StructsStaker, epoch uint32) error { + epochLastCommitted, err := razorUtils.GetEpochLastCommitted(rpcParameters, staker.Id) if err != nil { return err } @@ -30,8 +30,8 @@ func (*UtilsStruct) CheckForLastCommitted(client *ethclient.Client, staker bindi } //This function checks if the state is reveal or not and then reveals the votes -func (*UtilsStruct) Reveal(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, latestHeader *Types.Header, commitData types.CommitData, signature []byte) (common.Hash, error) { - if state, err := razorUtils.GetBufferedState(client, latestHeader, config.BufferPercent); err != nil || state != 1 { +func (*UtilsStruct) Reveal(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, latestHeader *Types.Header, stateBuffer uint64, commitData types.CommitData, signature []byte) (common.Hash, error) { + if state, err := razorUtils.GetBufferedState(latestHeader, stateBuffer, config.BufferPercent); err != nil || state != 1 { log.Error("Not reveal state") return core.NilHash, err } @@ -55,8 +55,7 @@ func (*UtilsStruct) Reveal(client *ethclient.Client, config types.Configurations log.Info("Revealing votes...") - txnOpts := razorUtils.GetTxnOpts(types.TransactionOptions{ - Client: client, + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{ ChainId: core.ChainId, Config: config, ContractAddress: core.VoteManagerAddress, @@ -65,6 +64,17 @@ func (*UtilsStruct) Reveal(client *ethclient.Client, config types.Configurations Parameters: []interface{}{epoch, treeRevealData, signature}, Account: account, }) + if err != nil { + log.Error(err) + return core.NilHash, err + } + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + log.Error(err) + return core.NilHash, err + } + log.Debugf("Executing Reveal transaction wih epoch = %d, treeRevealData = %v, signature = %v", epoch, treeRevealData, signature) txn, err := voteManagerUtils.Reveal(client, txnOpts, epoch, treeRevealData, signature) if err != nil { @@ -112,9 +122,9 @@ func (*UtilsStruct) GenerateTreeRevealData(merkleTree [][][]byte, commitData typ } //This function indexes the reveal events of current epoch -func (*UtilsStruct) IndexRevealEventsOfCurrentEpoch(client *ethclient.Client, blockNumber *big.Int, epoch uint32) ([]types.RevealedStruct, error) { +func (*UtilsStruct) IndexRevealEventsOfCurrentEpoch(rpcParameters rpc.RPCParameters, blockNumber *big.Int, epoch uint32) ([]types.RevealedStruct, error) { log.Debug("Fetching reveal events of current epoch...") - fromBlock, err := razorUtils.EstimateBlockNumberAtEpochBeginning(client, blockNumber) + fromBlock, err := razorUtils.EstimateBlockNumberAtEpochBeginning(rpcParameters, blockNumber) if err != nil { return nil, errors.New("Not able to Fetch Block: " + err.Error()) } @@ -127,7 +137,7 @@ func (*UtilsStruct) IndexRevealEventsOfCurrentEpoch(client *ethclient.Client, bl }, } log.Debugf("IndexRevealEventsOfCurrentEpoch: Query to send in filter logs: %+v", query) - logs, err := clientUtils.FilterLogsWithRetry(client, query) + logs, err := clientUtils.FilterLogsWithRetry(rpcParameters, query) if err != nil { return nil, err } diff --git a/cmd/reveal_test.go b/cmd/reveal_test.go index c276ade07..db5d5b1d5 100644 --- a/cmd/reveal_test.go +++ b/cmd/reveal_test.go @@ -13,12 +13,10 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/mock" ) func TestCheckForLastCommitted(t *testing.T) { - var client *ethclient.Client staker := bindings.StructsStaker{ Id: 1, } @@ -65,11 +63,11 @@ func TestCheckForLastCommitted(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetEpochLastCommitted", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.epochLastCommitted, tt.args.epochLastCommittedErr) + utilsMock.On("GetEpochLastCommitted", mock.Anything, mock.Anything).Return(tt.args.epochLastCommitted, tt.args.epochLastCommittedErr) utils := &UtilsStruct{} - err := utils.CheckForLastCommitted(client, staker, tt.args.epoch) + err := utils.CheckForLastCommitted(rpcParameters, staker, tt.args.epoch) if err == nil || tt.want == nil { if err != tt.want { t.Errorf("Error for CheckForLastCommitted function, got = %v, want %v", err, tt.want) @@ -86,13 +84,13 @@ func TestCheckForLastCommitted(t *testing.T) { func TestReveal(t *testing.T) { var ( - client *ethclient.Client commitData types.CommitData signature []byte account types.Account config types.Configurations epoch uint32 latestHeader *Types.Header + stateBuffer uint64 ) type args struct { @@ -101,6 +99,7 @@ func TestReveal(t *testing.T) { merkleTree [][][]byte merkleTreeErr error treeRevealData bindings.StructsMerkleTree + txnOptsErr error revealTxn *Types.Transaction revealErr error hash common.Hash @@ -135,7 +134,7 @@ func TestReveal(t *testing.T) { wantErr: errors.New("state error"), }, { - name: "Test 6: When Reveal transaction fails", + name: "Test 3: When Reveal transaction fails", args: args{ state: 1, stateErr: nil, @@ -147,7 +146,7 @@ func TestReveal(t *testing.T) { wantErr: errors.New("reveal error"), }, { - name: "Test 7: When there is an error in getting merkle tree", + name: "Test 4: When there is an error in getting merkle tree", args: args{ state: 1, merkleTreeErr: errors.New("merkle tree error"), @@ -155,6 +154,16 @@ func TestReveal(t *testing.T) { want: core.NilHash, wantErr: errors.New("merkle tree error"), }, + { + name: "Test 5: When there is an error in getting txnOpts", + args: args{ + state: 1, + stateErr: nil, + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -163,13 +172,13 @@ func TestReveal(t *testing.T) { utilsMock.On("GetBufferedState", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.state, tt.args.stateErr) merkleUtilsMock.On("CreateMerkle", mock.Anything).Return(tt.args.merkleTree, tt.args.merkleTreeErr) cmdUtilsMock.On("GenerateTreeRevealData", mock.Anything, mock.Anything).Return(tt.args.treeRevealData) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetTxnOpts", mock.Anything, mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts, tt.args.txnOptsErr) voteManagerMock.On("Reveal", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.TransactOpts"), mock.AnythingOfType("uint32"), mock.Anything, mock.Anything).Return(tt.args.revealTxn, tt.args.revealErr) transactionMock.On("Hash", mock.AnythingOfType("*types.Transaction")).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.Reveal(client, config, account, epoch, latestHeader, commitData, signature) + got, err := utils.Reveal(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitData, signature) if got != tt.want { t.Errorf("Txn hash for Reveal function, got = %v, want = %v", got, tt.want) } @@ -255,7 +264,6 @@ func TestGenerateTreeRevealData(t *testing.T) { func TestIndexRevealEventsOfCurrentEpoch(t *testing.T) { var ( - client *ethclient.Client blockNumber *big.Int epoch uint32 ) @@ -319,12 +327,12 @@ func TestIndexRevealEventsOfCurrentEpoch(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("EstimateBlockNumberAtEpochBeginning", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.fromBlock, tt.args.fromBlockErr) - clientUtilsMock.On("FilterLogsWithRetry", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("ethereum.FilterQuery")).Return(tt.args.logs, tt.args.logsErr) + utilsMock.On("EstimateBlockNumberAtEpochBeginning", mock.Anything, mock.Anything).Return(tt.args.fromBlock, tt.args.fromBlockErr) + clientUtilsMock.On("FilterLogsWithRetry", mock.Anything, mock.Anything).Return(tt.args.logs, tt.args.logsErr) abiUtilsMock.On("Parse", mock.Anything).Return(tt.args.contractAbi, tt.args.contractAbiErr) abiUtilsMock.On("Unpack", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.data, tt.args.unpackErr) ut := &UtilsStruct{} - got, err := ut.IndexRevealEventsOfCurrentEpoch(client, blockNumber, epoch) + got, err := ut.IndexRevealEventsOfCurrentEpoch(rpcParameters, blockNumber, epoch) if (err != nil) != tt.wantErr { t.Errorf("IndexRevealEventsOfCurrentEpoch() error = %v, wantErr %v", err, tt.wantErr) return diff --git a/cmd/root.go b/cmd/root.go index 56eca6b7b..d072d3cf9 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -14,7 +14,6 @@ import ( var ( Provider string - AlternateProvider string GasMultiplier float32 BufferPercent int32 WaitTime int32 @@ -30,7 +29,7 @@ var ( LogFileMaxAge int ) -var log = logger.NewLogger() +var log = logger.GetLogger() // rootCmd represents the base command when called without any subcommands var rootCmd = &cobra.Command{ @@ -61,7 +60,6 @@ func init() { cobra.OnInitialize(initConfig) rootCmd.PersistentFlags().StringVarP(&Provider, "provider", "p", "", "provider name") - rootCmd.PersistentFlags().StringVarP(&AlternateProvider, "alternateProvider", "", "", "alternate provider name") rootCmd.PersistentFlags().Float32VarP(&GasMultiplier, "gasmultiplier", "g", -1, "gas multiplier value") rootCmd.PersistentFlags().Int32VarP(&BufferPercent, "buffer", "b", 0, "buffer percent") rootCmd.PersistentFlags().Int32VarP(&WaitTime, "wait", "w", -1, "wait time") diff --git a/cmd/setConfig.go b/cmd/setConfig.go index 7f0ad8746..4008bbcd6 100644 --- a/cmd/setConfig.go +++ b/cmd/setConfig.go @@ -34,7 +34,6 @@ func (*UtilsStruct) SetConfig(flagSet *pflag.FlagSet) error { flagDetails := []types.FlagDetail{ {Name: "provider", Type: "string"}, - {Name: "alternateProvider", Type: "string"}, {Name: "gasmultiplier", Type: "float32"}, {Name: "buffer", Type: "int32"}, {Name: "wait", Type: "int32"}, @@ -62,7 +61,6 @@ func (*UtilsStruct) SetConfig(flagSet *pflag.FlagSet) error { configDetails := []types.ConfigDetail{ {FlagName: "provider", Key: "provider", DefaultValue: ""}, - {FlagName: "alternateProvider", Key: "alternateProvider", DefaultValue: ""}, {FlagName: "gasmultiplier", Key: "gasmultiplier", DefaultValue: core.DefaultGasMultiplier}, {FlagName: "buffer", Key: "buffer", DefaultValue: core.DefaultBufferPercent}, {FlagName: "wait", Key: "wait", DefaultValue: core.DefaultWaitTime}, @@ -152,7 +150,6 @@ func init() { var ( Provider string - AlternateProvider string GasMultiplier float32 BufferPercent int32 WaitTime int32 @@ -170,7 +167,6 @@ func init() { LogFileMaxAge int ) setConfig.Flags().StringVarP(&Provider, "provider", "p", "", "provider name") - setConfig.Flags().StringVarP(&AlternateProvider, "alternateProvider", "", "", "alternate provider name") setConfig.Flags().Float32VarP(&GasMultiplier, "gasmultiplier", "g", -1, "gas multiplier value") setConfig.Flags().Int32VarP(&BufferPercent, "buffer", "b", 0, "buffer percent") setConfig.Flags().Int32VarP(&WaitTime, "wait", "w", 0, "wait time (in secs)") diff --git a/cmd/setConfig_test.go b/cmd/setConfig_test.go index b25f7a858..2b88b6316 100644 --- a/cmd/setConfig_test.go +++ b/cmd/setConfig_test.go @@ -2,6 +2,7 @@ package cmd import ( "errors" + "razor/core/types" "testing" "github.com/spf13/pflag" @@ -74,7 +75,10 @@ func TestSetConfig(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + cmdUtilsMock.On("GetConfigData").Return(types.Configurations{}, nil) + utilsMock.On("IsFlagPassed", mock.Anything).Return(false) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) flagSetMock.On("FetchFlagInput", flagSet, mock.Anything, mock.Anything).Return(tt.args.flagInput, tt.args.flagInputErr) flagSetMock.On("Changed", mock.Anything, mock.Anything).Return(tt.args.isFlagPassed) diff --git a/cmd/setDelegation.go b/cmd/setDelegation.go index f28ca97d3..338e57656 100644 --- a/cmd/setDelegation.go +++ b/cmd/setDelegation.go @@ -2,15 +2,13 @@ package cmd import ( - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/pflag" "github.com/spf13/cobra" @@ -34,30 +32,8 @@ func initialiseSetDelegation(cmd *cobra.Command, args []string) { //This function sets the flags appropriately and executes the SetDelegation function func (*UtilsStruct) ExecuteSetDelegation(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteSetDelegation: Config: %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) statusString, err := flagSetUtils.GetStringStatus(flagSet) utils.CheckError("Error in getting status: ", err) @@ -65,7 +41,7 @@ func (*UtilsStruct) ExecuteSetDelegation(flagSet *pflag.FlagSet) { status, err := stringUtils.ParseBool(statusString) utils.CheckError("Error in parsing status to boolean: ", err) - stakerId, err := razorUtils.GetStakerId(client, address) + stakerId, err := razorUtils.GetStakerId(rpcParameters, account.Address) utils.CheckError("StakerId error: ", err) commission, err := flagSetUtils.GetUint8Commission(flagSet) @@ -79,17 +55,17 @@ func (*UtilsStruct) ExecuteSetDelegation(flagSet *pflag.FlagSet) { Account: account, } - txn, err := cmdUtils.SetDelegation(client, config, delegationInput) + txn, err := cmdUtils.SetDelegation(rpcParameters, config, delegationInput) utils.CheckError("SetDelegation error: ", err) if txn != core.NilHash { - err = razorUtils.WaitForBlockCompletion(client, txn.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txn.Hex()) utils.CheckError("Error in WaitForBlockCompletion for setDelegation: ", err) } } //This function allows the staker to start accepting/rejecting delegation requests -func (*UtilsStruct) SetDelegation(client *ethclient.Client, config types.Configurations, delegationInput types.SetDelegationInput) (common.Hash, error) { - stakerInfo, err := razorUtils.GetStaker(client, delegationInput.StakerId) +func (*UtilsStruct) SetDelegation(rpcParameters rpc.RPCParameters, config types.Configurations, delegationInput types.SetDelegationInput) (common.Hash, error) { + stakerInfo, err := razorUtils.GetStaker(rpcParameters, delegationInput.StakerId) if err != nil { return core.NilHash, err } @@ -100,14 +76,13 @@ func (*UtilsStruct) SetDelegation(client *ethclient.Client, config types.Configu Commission: delegationInput.Commission, Account: delegationInput.Account, } - err = cmdUtils.UpdateCommission(config, client, updateCommissionInput) + err = cmdUtils.UpdateCommission(rpcParameters, config, updateCommissionInput) if err != nil { return core.NilHash, err } } txnOpts := types.TransactionOptions{ - Client: client, ChainId: core.ChainId, Config: config, ContractAddress: core.StakeManagerAddress, @@ -122,7 +97,16 @@ func (*UtilsStruct) SetDelegation(client *ethclient.Client, config types.Configu return core.NilHash, nil } log.Infof("Setting delegation acceptance of Staker %d to %t", delegationInput.StakerId, delegationInput.Status) - setDelegationAcceptanceTxnOpts := razorUtils.GetTxnOpts(txnOpts) + setDelegationAcceptanceTxnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnOpts) + if err != nil { + return core.NilHash, err + } + + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debug("Executing SetDelegationAcceptance transaction with status ", delegationInput.Status) delegationAcceptanceTxn, err := stakeManagerUtils.SetDelegationAcceptance(client, setDelegationAcceptanceTxnOpts, delegationInput.Status) if err != nil { diff --git a/cmd/setDelegation_test.go b/cmd/setDelegation_test.go index e9cc4b2b1..c7b812a14 100644 --- a/cmd/setDelegation_test.go +++ b/cmd/setDelegation_test.go @@ -4,11 +4,9 @@ import ( "errors" "math/big" "razor/accounts" - "razor/cmd/mocks" "razor/core" "razor/core/types" "razor/pkg/bindings" - utilsPkgMocks "razor/utils/mocks" "testing" "github.com/ethereum/go-ethereum/common" @@ -19,8 +17,6 @@ import ( ) func TestSetDelegation(t *testing.T) { - - var client *ethclient.Client var config = types.Configurations{ Provider: "127.0.0.1", GasMultiplier: 1, @@ -32,6 +28,7 @@ func TestSetDelegation(t *testing.T) { status bool staker bindings.StructsStaker stakerErr error + txnOptsErr error setDelegationAcceptanceTxn *Types.Transaction setDelegationAcceptanceErr error hash common.Hash @@ -130,28 +127,31 @@ func TestSetDelegation(t *testing.T) { want: core.NilHash, wantErr: errors.New("error in updating commission"), }, + { + name: "Test 7: When there is an error in getting txnOpts", + args: args{ + staker: bindings.StructsStaker{ + AcceptDelegation: true, + }, + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - utilsMock := new(utilsPkgMocks.Utils) - stakeManagerUtilsMock := new(mocks.StakeManagerInterface) - transactionUtilsMock := new(mocks.TransactionInterface) - cmdUtilsMock := new(mocks.UtilsCmdInterface) - - razorUtils = utilsMock - stakeManagerUtils = stakeManagerUtilsMock - transactionUtils = transactionUtilsMock - cmdUtils = cmdUtilsMock + SetUpMockInterfaces() - utilsMock.On("GetStaker", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.staker, tt.args.stakerErr) + utilsMock.On("GetStaker", mock.Anything, mock.Anything).Return(tt.args.staker, tt.args.stakerErr) cmdUtilsMock.On("UpdateCommission", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.UpdateCommissionErr) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) - stakeManagerUtilsMock.On("SetDelegationAcceptance", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.AnythingOfType("bool")).Return(tt.args.setDelegationAcceptanceTxn, tt.args.setDelegationAcceptanceErr) - transactionUtilsMock.On("Hash", mock.Anything).Return(tt.args.hash) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) + stakeManagerMock.On("SetDelegationAcceptance", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.AnythingOfType("bool")).Return(tt.args.setDelegationAcceptanceTxn, tt.args.setDelegationAcceptanceErr) + transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.SetDelegation(client, config, types.SetDelegationInput{ + got, err := utils.SetDelegation(rpcParameters, config, types.SetDelegationInput{ Status: tt.args.status, Commission: tt.args.commission, }) @@ -381,40 +381,30 @@ func TestExecuteSetDelegation(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - utilsMock := new(utilsPkgMocks.Utils) - cmdUtilsMock := new(mocks.UtilsCmdInterface) - flagSetUtilsMock := new(mocks.FlagSetInterface) - stakeManagerUtilsMock := new(mocks.StakeManagerInterface) - stringMock := new(mocks.StringInterface) - fileUtilsMock := new(utilsPkgMocks.FileUtils) - - razorUtils = utilsMock - cmdUtils = cmdUtilsMock - flagSetUtils = flagSetUtilsMock - stakeManagerUtils = stakeManagerUtilsMock - stringUtils = stringMock - fileUtils = fileUtilsMock + SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("AssignPassword", flagSet).Return(tt.args.password) utilsMock.On("CheckPassword", mock.Anything).Return(nil) utilsMock.On("AccountManagerForKeystore").Return(&accounts.AccountManager{}, nil) - flagSetUtilsMock.On("GetStringAddress", flagSet).Return(tt.args.address, tt.args.addressErr) - flagSetUtilsMock.On("GetStringStatus", flagSet).Return(tt.args.status, tt.args.statusErr) - flagSetUtilsMock.On("GetUint8Commission", flagSet).Return(tt.args.commission, tt.args.commissionErr) + flagSetMock.On("GetStringAddress", flagSet).Return(tt.args.address, tt.args.addressErr) + flagSetMock.On("GetStringStatus", flagSet).Return(tt.args.status, tt.args.statusErr) + flagSetMock.On("GetUint8Commission", flagSet).Return(tt.args.commission, tt.args.commissionErr) stringMock.On("ParseBool", mock.AnythingOfType("string")).Return(tt.args.parseStatus, tt.args.parseStatusErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - utilsMock.On("GetStakerId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.stakerId, tt.args.stakerIdErr) - cmdUtilsMock.On("SetDelegation", mock.AnythingOfType("*ethclient.Client"), config, mock.Anything).Return(tt.args.setDelegationHash, tt.args.setDelegationErr) - utilsMock.On("WaitForBlockCompletion", client, mock.AnythingOfType("string")).Return(nil) + utilsMock.On("GetStakerId", mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) + cmdUtilsMock.On("SetDelegation", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.setDelegationHash, tt.args.setDelegationErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) utils := &UtilsStruct{} fatal = false diff --git a/cmd/stakerInfo.go b/cmd/stakerInfo.go index 0778117ef..364c7c9d5 100644 --- a/cmd/stakerInfo.go +++ b/cmd/stakerInfo.go @@ -2,12 +2,11 @@ package cmd import ( - "github.com/ethereum/go-ethereum/ethclient" "github.com/olekukonko/tablewriter" "github.com/spf13/cobra" "github.com/spf13/pflag" "os" - "razor/logger" + "razor/rpc" "razor/utils" "strconv" ) @@ -29,39 +28,34 @@ func initialiseStakerInfo(cmd *cobra.Command, args []string) { //This function sets the flag appropriately and executes the GetStakerInfo function func (*UtilsStruct) ExecuteStakerinfo(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteStakerinfo: Config: %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - logger.SetLoggerParameters(client, "") + _, rpcParameters, _, _, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) stakerId, err := flagSetUtils.GetUint32StakerId(flagSet) utils.CheckError("Error in getting stakerId: ", err) log.Debug("ExecuteStakerinfo: StakerId: ", stakerId) log.Debug("ExecuteStakerinfo: Calling GetStakerInfo() with argument stakerId = ", stakerId) - err = cmdUtils.GetStakerInfo(client, stakerId) + err = cmdUtils.GetStakerInfo(rpcParameters, stakerId) utils.CheckError("Error in getting staker info: ", err) } //This function provides the staker details like age, stake, maturity etc. -func (*UtilsStruct) GetStakerInfo(client *ethclient.Client, stakerId uint32) error { - callOpts := razorUtils.GetOptions() - stakerInfo, err := stakeManagerUtils.StakerInfo(client, &callOpts, stakerId) +func (*UtilsStruct) GetStakerInfo(rpcParameters rpc.RPCParameters, stakerId uint32) error { + stakerInfo, err := razorUtils.StakerInfo(rpcParameters, stakerId) if err != nil { return err } - maturity, err := stakeManagerUtils.GetMaturity(client, &callOpts, stakerInfo.Age) + maturity, err := razorUtils.GetMaturity(rpcParameters, stakerInfo.Age) if err != nil { return err } - epoch, err := razorUtils.GetEpoch(client) + epoch, err := razorUtils.GetEpoch(rpcParameters) if err != nil { return err } - influence, err := razorUtils.GetInfluenceSnapshot(client, stakerId, epoch) + influence, err := razorUtils.GetInfluenceSnapshot(rpcParameters, stakerId, epoch) if err != nil { return err } diff --git a/cmd/stakerInfo_test.go b/cmd/stakerInfo_test.go index c73676722..170b00b17 100644 --- a/cmd/stakerInfo_test.go +++ b/cmd/stakerInfo_test.go @@ -9,14 +9,11 @@ import ( "github.com/spf13/pflag" "github.com/stretchr/testify/mock" "math/big" - "razor/cmd/mocks" "razor/core/types" - utilsPkgMocks "razor/utils/mocks" "testing" ) func TestUtilsStruct_GetStakerInfo(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts stake, _ := new(big.Int).SetString("10000000000000000000000", 10) @@ -31,7 +28,6 @@ func TestUtilsStruct_GetStakerInfo(t *testing.T) { } type args struct { - client *ethclient.Client stakerId uint32 callOpts bind.CallOpts stakerInfo types.Staker @@ -53,7 +49,6 @@ func TestUtilsStruct_GetStakerInfo(t *testing.T) { name: "Test 1: When StakerInfo executes properly", fields: testUtils, args: args{ - client: client, stakerId: 1, callOpts: bind.CallOpts{ Pending: false, @@ -85,7 +80,6 @@ func TestUtilsStruct_GetStakerInfo(t *testing.T) { name: "Test 2: When there is error fetching staker info", fields: testUtils, args: args{ - client: client, stakerId: 1, callOpts: bind.CallOpts{ Pending: false, @@ -117,7 +111,6 @@ func TestUtilsStruct_GetStakerInfo(t *testing.T) { name: "Test 3: When there is error fetching maturity", fields: testUtils, args: args{ - client: client, stakerId: 1, callOpts: bind.CallOpts{ Pending: false, @@ -149,7 +142,6 @@ func TestUtilsStruct_GetStakerInfo(t *testing.T) { name: "Test 4: When there is error fetching influence", fields: testUtils, args: args{ - client: client, stakerId: 1, callOpts: bind.CallOpts{ Pending: false, @@ -181,7 +173,6 @@ func TestUtilsStruct_GetStakerInfo(t *testing.T) { name: "Test 5: When there is error fetching epoch", fields: testUtils, args: args{ - client: client, stakerId: 1, callOpts: bind.CallOpts{ Pending: false, @@ -213,19 +204,15 @@ func TestUtilsStruct_GetStakerInfo(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - utilsMock := new(utilsPkgMocks.Utils) - stakeManagerMock := new(mocks.StakeManagerInterface) - - razorUtils = utilsMock - stakeManagerUtils = stakeManagerMock + SetUpMockInterfaces() utilsMock.On("GetOptions").Return(callOpts) - stakeManagerMock.On("StakerInfo", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.CallOpts"), mock.AnythingOfType("uint32")).Return(tt.args.stakerInfo, tt.args.stakerInfoErr) - stakeManagerMock.On("GetMaturity", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.CallOpts"), mock.AnythingOfType("uint32")).Return(tt.args.maturity, tt.args.maturityErr) - utilsMock.On("GetInfluenceSnapshot", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(tt.args.influence, tt.args.influenceErr) - utilsMock.On("GetEpoch", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epoch, tt.args.epochErr) + utilsMock.On("StakerInfo", mock.Anything, mock.Anything).Return(tt.args.stakerInfo, tt.args.stakerInfoErr) + utilsMock.On("GetMaturity", mock.Anything, mock.AnythingOfType("uint32")).Return(tt.args.maturity, tt.args.maturityErr) + utilsMock.On("GetInfluenceSnapshot", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.influence, tt.args.influenceErr) + utilsMock.On("GetEpoch", mock.Anything).Return(tt.args.epoch, tt.args.epochErr) utils := &UtilsStruct{} - err := utils.GetStakerInfo(tt.args.client, tt.args.stakerId) + err := utils.GetStakerInfo(rpcParameters, tt.args.stakerId) if err == nil || tt.wantErr == nil { if err != tt.wantErr { t.Errorf("Error for StakerInfo function, got = %v, want %v", err, tt.wantErr) @@ -301,27 +288,21 @@ func TestUtilsStruct_ExecuteStakerinfo(t *testing.T) { expectedFatal: true, }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - utilsMock := new(utilsPkgMocks.Utils) - cmdUtilsMock := new(mocks.UtilsCmdInterface) - flagSetUtilsMock := new(mocks.FlagSetInterface) - fileUtilsMock := new(utilsPkgMocks.FileUtils) - - razorUtils = utilsMock - cmdUtils = cmdUtilsMock - flagSetUtils = flagSetUtilsMock - fileUtils = fileUtilsMock + SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(false) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - flagSetUtilsMock.On("GetUint32StakerId", flagSet).Return(tt.args.stakerId, tt.args.stakerIdErr) - cmdUtilsMock.On("GetStakerInfo", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.stakerInfoErr) + flagSetMock.On("GetUint32StakerId", flagSet).Return(tt.args.stakerId, tt.args.stakerIdErr) + cmdUtilsMock.On("GetStakerInfo", mock.Anything, mock.Anything).Return(tt.args.stakerInfoErr) utils := &UtilsStruct{} fatal = false diff --git a/cmd/struct-utils.go b/cmd/struct-utils.go index eebc2712f..febc79d30 100644 --- a/cmd/struct-utils.go +++ b/cmd/struct-utils.go @@ -10,6 +10,7 @@ import ( "razor/core/types" "razor/path" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "strconv" "time" @@ -194,58 +195,6 @@ func (stakeManagerUtils StakeManagerUtils) RedeemBounty(client *ethclient.Client return ExecuteTransaction(stakeManager, "RedeemBounty", opts, bountyId) } -//This function returns the staker Info -func (stakeManagerUtils StakeManagerUtils) StakerInfo(client *ethclient.Client, opts *bind.CallOpts, stakerId uint32) (types.Staker, error) { - stakeManager := razorUtils.GetStakeManager(client) - returnedValues := utils.InvokeFunctionWithTimeout(stakeManager, "Stakers", opts, stakerId) - returnedError := utils.CheckIfAnyError(returnedValues) - if returnedError != nil { - return types.Staker{}, returnedError - } - staker := returnedValues[0].Interface().(struct { - AcceptDelegation bool - IsSlashed bool - Commission uint8 - Id uint32 - Age uint32 - Address common.Address - TokenAddress common.Address - EpochFirstStakedOrLastPenalized uint32 - EpochCommissionLastUpdated uint32 - Stake *big.Int - StakerReward *big.Int - }) - return staker, nil -} - -//This function returns the maturity -func (stakeManagerUtils StakeManagerUtils) GetMaturity(client *ethclient.Client, opts *bind.CallOpts, age uint32) (uint16, error) { - stakeManager := razorUtils.GetStakeManager(client) - index := age / 10000 - returnedValues := utils.InvokeFunctionWithTimeout(stakeManager, "Maturities", opts, big.NewInt(int64(index))) - returnedError := utils.CheckIfAnyError(returnedValues) - if returnedError != nil { - return 0, returnedError - } - return returnedValues[0].Interface().(uint16), nil -} - -//This function returns the bounty lock -func (stakeManagerUtils StakeManagerUtils) GetBountyLock(client *ethclient.Client, opts *bind.CallOpts, bountyId uint32) (types.BountyLock, error) { - stakeManager := razorUtils.GetStakeManager(client) - returnedValues := utils.InvokeFunctionWithTimeout(stakeManager, "BountyLocks", opts, bountyId) - returnedError := utils.CheckIfAnyError(returnedValues) - if returnedError != nil { - return types.BountyLock{}, returnedError - } - bountyLock := returnedValues[0].Interface().(struct { - RedeemAfter uint32 - BountyHunter common.Address - Amount *big.Int - }) - return bountyLock, nil -} - //This function is used to claim the staker reward func (stakeManagerUtils StakeManagerUtils) ClaimStakerReward(client *ethclient.Client, opts *bind.TransactOpts) (*Types.Transaction, error) { stakeManager := razorUtils.GetStakeManager(client) @@ -386,30 +335,15 @@ func (blockManagerUtils BlockManagerUtils) Propose(client *ethclient.Client, opt } //This function returns the sorted Ids -func (blockManagerUtils BlockManagerUtils) GiveSorted(blockManager *bindings.BlockManager, opts *bind.TransactOpts, epoch uint32, leafId uint16, sortedValues []*big.Int) (*Types.Transaction, error) { +func (blockManagerUtils BlockManagerUtils) GiveSorted(client *ethclient.Client, opts *bind.TransactOpts, epoch uint32, leafId uint16, sortedValues []*big.Int) (*Types.Transaction, error) { + blockManager := razorUtils.GetBlockManager(client) return ExecuteTransaction(blockManager, "GiveSorted", opts, epoch, leafId, sortedValues) } //This function resets the dispute -func (blockManagerUtils BlockManagerUtils) ResetDispute(blockManager *bindings.BlockManager, opts *bind.TransactOpts, epoch uint32) (*Types.Transaction, error) { - return ExecuteTransaction(blockManager, "ResetDispute", opts, epoch) -} - -// This functiom gets Disputes mapping -func (blockManagerUtils BlockManagerUtils) Disputes(client *ethclient.Client, opts *bind.CallOpts, epoch uint32, address common.Address) (types.DisputesStruct, error) { +func (blockManagerUtils BlockManagerUtils) ResetDispute(client *ethclient.Client, opts *bind.TransactOpts, epoch uint32) (*Types.Transaction, error) { blockManager := razorUtils.GetBlockManager(client) - returnedValues := utils.InvokeFunctionWithTimeout(blockManager, "Disputes", opts, epoch, address) - returnedError := utils.CheckIfAnyError(returnedValues) - if returnedError != nil { - return types.DisputesStruct{}, returnedError - } - disputesMapping := returnedValues[0].Interface().(struct { - LeafId uint16 - LastVisitedValue *big.Int - AccWeight *big.Int - Median *big.Int - }) - return disputesMapping, nil + return ExecuteTransaction(blockManager, "ResetDispute", opts, epoch) } //This function is used to reveal the values @@ -454,17 +388,6 @@ func (voteManagerUtils VoteManagerUtils) Commit(client *ethclient.Client, opts * return txn, nil } -//This function is used to check the allowance of staker -func (tokenManagerUtils TokenManagerUtils) Allowance(client *ethclient.Client, opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { - tokenManager := razorUtils.GetTokenManager(client) - returnedValues := utils.InvokeFunctionWithTimeout(tokenManager, "Allowance", opts, owner, spender) - returnedError := utils.CheckIfAnyError(returnedValues) - if returnedError != nil { - return nil, returnedError - } - return returnedValues[0].Interface().(*big.Int), nil -} - //This function is used to approve the transaction func (tokenManagerUtils TokenManagerUtils) Approve(client *ethclient.Client, opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*Types.Transaction, error) { tokenManager := razorUtils.GetTokenManager(client) @@ -693,8 +616,8 @@ func (c CryptoUtils) HexToECDSA(hexKey string) (*ecdsa.PrivateKey, error) { } //This function is used to give the sorted Ids -func (*UtilsStruct) GiveSorted(client *ethclient.Client, blockManager *bindings.BlockManager, txnArgs types.TransactionOptions, epoch uint32, assetId uint16, sortedStakers []*big.Int) error { - return GiveSorted(client, blockManager, txnArgs, epoch, assetId, sortedStakers) +func (*UtilsStruct) GiveSorted(rpcParameters rpc.RPCParameters, txnArgs types.TransactionOptions, epoch uint32, assetId uint16, sortedStakers []*big.Int) error { + return GiveSorted(rpcParameters, txnArgs, epoch, assetId, sortedStakers) } //This function is used to write config as diff --git a/cmd/transfer.go b/cmd/transfer.go index bbb7517b1..c1c44c162 100644 --- a/cmd/transfer.go +++ b/cmd/transfer.go @@ -5,12 +5,10 @@ import ( "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" - "github.com/ethereum/go-ethereum/ethclient" - "github.com/spf13/pflag" "github.com/ethereum/go-ethereum/common" @@ -34,20 +32,14 @@ func initialiseTransfer(cmd *cobra.Command, args []string) { //This function sets the flag appropriately and executes the Transfer function func (*UtilsStruct) ExecuteTransfer(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteTransfer: Config: %+v", config) + config, rpcParameters, _, _, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) - client := razorUtils.ConnectToClient(config.Provider) + log.Debugf("ExecuteTransfer: Config: %+v", config) fromAddress, err := flagSetUtils.GetStringFrom(flagSet) utils.CheckError("Error in getting fromAddress: ", err) - logger.SetLoggerParameters(client, fromAddress) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - log.Debug("Getting password...") password := razorUtils.AssignPassword(flagSet) @@ -62,7 +54,7 @@ func (*UtilsStruct) ExecuteTransfer(flagSet *pflag.FlagSet) { toAddress, err := flagSetUtils.GetStringTo(flagSet) utils.CheckError("Error in getting toAddress: ", err) - balance, err := razorUtils.FetchBalance(client, fromAddress) + balance, err := razorUtils.FetchBalance(rpcParameters, account.Address) utils.CheckError("Error in fetching razor balance: ", err) log.Debug("Getting amount in wei...") @@ -76,20 +68,19 @@ func (*UtilsStruct) ExecuteTransfer(flagSet *pflag.FlagSet) { Account: account, } - txn, err := cmdUtils.Transfer(client, config, transferInput) + txn, err := cmdUtils.Transfer(rpcParameters, config, transferInput) utils.CheckError("Transfer error: ", err) - err = razorUtils.WaitForBlockCompletion(client, txn.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txn.Hex()) utils.CheckError("Error in WaitForBlockCompletion for transfer: ", err) } //This function transfers the razors from your account to others account -func (*UtilsStruct) Transfer(client *ethclient.Client, config types.Configurations, transferInput types.TransferInput) (common.Hash, error) { +func (*UtilsStruct) Transfer(rpcParameters rpc.RPCParameters, config types.Configurations, transferInput types.TransferInput) (common.Hash, error) { log.Debug("Checking for sufficient balance...") razorUtils.CheckAmountAndBalance(transferInput.ValueInWei, transferInput.Balance) - txnOpts := razorUtils.GetTxnOpts(types.TransactionOptions{ - Client: client, + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{ ChainId: core.ChainId, Config: config, ContractAddress: core.RAZORAddress, @@ -98,7 +89,14 @@ func (*UtilsStruct) Transfer(client *ethclient.Client, config types.Configuratio ABI: bindings.RAZORMetaData.ABI, Account: transferInput.Account, }) + if err != nil { + return core.NilHash, err + } log.Infof("Transferring %g tokens from %s to %s", utils.GetAmountInDecimal(transferInput.ValueInWei), transferInput.Account.Address, transferInput.ToAddress) + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } log.Debugf("Executing Transfer transaction with toAddress: %s, amount: %s", transferInput.ToAddress, transferInput.ValueInWei) txn, err := tokenManagerUtils.Transfer(client, txnOpts, common.HexToAddress(transferInput.ToAddress), transferInput.ValueInWei) diff --git a/cmd/transfer_test.go b/cmd/transfer_test.go index d0e04e651..bf29f5235 100644 --- a/cmd/transfer_test.go +++ b/cmd/transfer_test.go @@ -17,12 +17,12 @@ import ( ) func TestTransfer(t *testing.T) { - var client *ethclient.Client var config types.Configurations type args struct { amount *big.Int decimalAmount *big.Float + txnOptsErr error transferTxn *Types.Transaction transferErr error transferHash common.Hash @@ -57,20 +57,30 @@ func TestTransfer(t *testing.T) { want: core.NilHash, wantErr: errors.New("transfer error"), }, + { + name: "When there is an error in getting txnOpts", + args: args{ + amount: big.NewInt(1).Mul(big.NewInt(1000), big.NewInt(1e18)), + decimalAmount: big.NewFloat(1000), + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() utilsMock.On("CheckAmountAndBalance", mock.AnythingOfType("*big.Int"), mock.AnythingOfType("*big.Int")).Return(tt.args.amount) - utilsMock.On("GetTxnOpts", mock.Anything).Return(TxnOpts) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) utilsMock.On("GetAmountInDecimal", mock.AnythingOfType("*big.Int")).Return(tt.args.decimalAmount) tokenManagerMock.On("Transfer", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.TransactOpts"), mock.AnythingOfType("common.Address"), mock.AnythingOfType("*big.Int")).Return(tt.args.transferTxn, tt.args.transferErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.transferHash) utils := &UtilsStruct{} - got, err := utils.Transfer(client, config, types.TransferInput{ + got, err := utils.Transfer(rpcParameters, config, types.TransferInput{ ValueInWei: big.NewInt(1).Mul(big.NewInt(1), big.NewInt(1e18)), }) if got != tt.want { @@ -235,14 +245,16 @@ func TestExecuteTransfer(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(false) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("AssignPassword", flagSet).Return(tt.args.password) @@ -252,9 +264,9 @@ func TestExecuteTransfer(t *testing.T) { flagSetMock.On("GetStringTo", flagSet).Return(tt.args.to, tt.args.toErr) cmdUtilsMock.On("AssignAmountInWei", flagSet).Return(tt.args.amount, tt.args.amountErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - utilsMock.On("FetchBalance", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.balance, tt.args.balanceErr) - cmdUtilsMock.On("Transfer", mock.AnythingOfType("*ethclient.Client"), config, mock.AnythingOfType("types.TransferInput")).Return(tt.args.transferHash, tt.args.transferErr) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) + utilsMock.On("FetchBalance", mock.Anything, mock.Anything).Return(tt.args.balance, tt.args.balanceErr) + cmdUtilsMock.On("Transfer", mock.Anything, config, mock.Anything).Return(tt.args.transferHash, tt.args.transferErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) utils := &UtilsStruct{} fatal = false diff --git a/cmd/unlockWithdraw.go b/cmd/unlockWithdraw.go index 5edd33c91..25f670592 100644 --- a/cmd/unlockWithdraw.go +++ b/cmd/unlockWithdraw.go @@ -4,16 +4,14 @@ package cmd import ( "errors" "math/big" - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/cobra" "github.com/spf13/pflag" ) @@ -33,48 +31,25 @@ func initializeUnlockWithdraw(cmd *cobra.Command, args []string) { //This function sets the flag appropriately and executes the UnlockWithdraw function func (*UtilsStruct) ExecuteUnlockWithdraw(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteUnlockWithdraw: Config: %+v", config) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - log.Debug("ExecuteUnlockWithdraw: Address: ", address) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) - - stakerId, err := razorUtils.AssignStakerId(flagSet, client, address) + stakerId, err := razorUtils.AssignStakerId(rpcParameters, flagSet, account.Address) utils.CheckError("Error in fetching stakerId: ", err) log.Debug("ExecuteUnlockWithdraw: StakerId: ", stakerId) - txn, err := cmdUtils.HandleWithdrawLock(client, account, config, stakerId) + txn, err := cmdUtils.HandleWithdrawLock(rpcParameters, account, config, stakerId) utils.CheckError("HandleWithdrawLock error: ", err) if txn != core.NilHash { - err = razorUtils.WaitForBlockCompletion(client, txn.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txn.Hex()) utils.CheckError("Error in WaitForBlockCompletion for unlockWithdraw: ", err) } } //This function handles the Withdraw lock -func (*UtilsStruct) HandleWithdrawLock(client *ethclient.Client, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) { - withdrawLock, err := razorUtils.GetLock(client, account.Address, stakerId, 1) +func (*UtilsStruct) HandleWithdrawLock(rpcParameters rpc.RPCParameters, account types.Account, configurations types.Configurations, stakerId uint32) (common.Hash, error) { + withdrawLock, err := razorUtils.GetLock(rpcParameters, account.Address, stakerId, 1) if err != nil { return core.NilHash, err } @@ -85,7 +60,7 @@ func (*UtilsStruct) HandleWithdrawLock(client *ethclient.Client, account types.A return core.NilHash, errors.New("initiate withdrawal of Razors before unlocking withdraw") } - epoch, err := razorUtils.GetEpoch(client) + epoch, err := razorUtils.GetEpoch(rpcParameters) if err != nil { log.Error("Error in fetching epoch") return core.NilHash, err @@ -101,7 +76,6 @@ func (*UtilsStruct) HandleWithdrawLock(client *ethclient.Client, account types.A if big.NewInt(int64(epoch)).Cmp(withdrawLock.UnlockAfter) >= 0 { txnArgs := types.TransactionOptions{ - Client: client, ChainId: core.ChainId, Config: configurations, ContractAddress: core.StakeManagerAddress, @@ -110,16 +84,23 @@ func (*UtilsStruct) HandleWithdrawLock(client *ethclient.Client, account types.A Parameters: []interface{}{stakerId}, Account: account, } - txnOpts := razorUtils.GetTxnOpts(txnArgs) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) + if err != nil { + return core.NilHash, err + } log.Debug("HandleWithdrawLock: Calling UnlockWithdraw() with arguments stakerId = ", stakerId) - return cmdUtils.UnlockWithdraw(client, txnOpts, stakerId) + return cmdUtils.UnlockWithdraw(rpcParameters, txnOpts, stakerId) } return core.NilHash, errors.New("withdrawLock period not over yet! Please try after some time") } //This function withdraws your razor once withdraw lock has passed -func (*UtilsStruct) UnlockWithdraw(client *ethclient.Client, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) { +func (*UtilsStruct) UnlockWithdraw(rpcParameters rpc.RPCParameters, txnOpts *bind.TransactOpts, stakerId uint32) (common.Hash, error) { log.Info("Unlocking funds...") + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } log.Debug("Executing UnlockWithdraw transaction with stakerId = ", stakerId) txn, err := stakeManagerUtils.UnlockWithdraw(client, txnOpts, stakerId) diff --git a/cmd/unlockWithdraw_test.go b/cmd/unlockWithdraw_test.go index 210613e20..1cf686c91 100644 --- a/cmd/unlockWithdraw_test.go +++ b/cmd/unlockWithdraw_test.go @@ -86,14 +86,16 @@ func TestExecuteUnlockWithdraw(t *testing.T) { expectedFatal: true, }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) flagSetMock.On("GetStringAddress", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.address, tt.args.addressErr) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) @@ -102,8 +104,8 @@ func TestExecuteUnlockWithdraw(t *testing.T) { utilsMock.On("AccountManagerForKeystore").Return(&accounts.AccountManager{}, nil) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) utilsMock.On("AssignStakerId", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) - cmdUtilsMock.On("HandleWithdrawLock", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything).Return(tt.args.txn, tt.args.err) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(nil) + cmdUtilsMock.On("HandleWithdrawLock", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.txn, tt.args.err) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) utils := &UtilsStruct{} utils.ExecuteUnlockWithdraw(flagSet) if fatal != tt.expectedFatal { @@ -115,7 +117,6 @@ func TestExecuteUnlockWithdraw(t *testing.T) { func TestHandleWithdrawLock(t *testing.T) { var ( - client *ethclient.Client account types.Account configurations types.Configurations stakerId uint32 @@ -126,6 +127,7 @@ func TestHandleWithdrawLock(t *testing.T) { withdrawLockErr error epoch uint32 epochErr error + txnOptsErr error unlockWithdraw common.Hash unlockWithdrawErr error time string @@ -190,18 +192,30 @@ func TestHandleWithdrawLock(t *testing.T) { want: core.NilHash, wantErr: false, }, + { + name: "Test 6: When there is an error in getting txnOpts", + args: args{ + withdrawLock: types.Locks{ + UnlockAfter: big.NewInt(4), + }, + epoch: 5, + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: true, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetLock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string"), mock.AnythingOfType("uint32"), mock.Anything).Return(tt.args.withdrawLock, tt.args.withdrawLockErr) - utilsMock.On("GetEpoch", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epoch, tt.args.epochErr) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetLock", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.withdrawLock, tt.args.withdrawLockErr) + utilsMock.On("GetEpoch", mock.Anything).Return(tt.args.epoch, tt.args.epochErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) cmdUtilsMock.On("UnlockWithdraw", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.unlockWithdraw, tt.args.unlockWithdrawErr) utilsMock.On("SecondsToReadableTime", mock.AnythingOfType("int")).Return(tt.args.time) ut := &UtilsStruct{} - got, err := ut.HandleWithdrawLock(client, account, configurations, stakerId) + got, err := ut.HandleWithdrawLock(rpcParameters, account, configurations, stakerId) if (err != nil) != tt.wantErr { t.Errorf("HandleWithdrawLock() error = %v, wantErr %v", err, tt.wantErr) return @@ -215,7 +229,6 @@ func TestHandleWithdrawLock(t *testing.T) { func TestUnlockWithdraw(t *testing.T) { var ( - client *ethclient.Client txnOpts *bind.TransactOpts stakerId uint32 ) @@ -256,7 +269,7 @@ func TestUnlockWithdraw(t *testing.T) { stakeManagerMock.On("UnlockWithdraw", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.TransactOpts"), mock.AnythingOfType("uint32")).Return(tt.args.txn, tt.args.txnErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) ut := &UtilsStruct{} - got, err := ut.UnlockWithdraw(client, txnOpts, stakerId) + got, err := ut.UnlockWithdraw(rpcParameters, txnOpts, stakerId) if (err != nil) != tt.wantErr { t.Errorf("UnlockWithdraw() error = %v, wantErr %v", err, tt.wantErr) return diff --git a/cmd/unstake.go b/cmd/unstake.go index af79f2591..e390ca5cc 100644 --- a/cmd/unstake.go +++ b/cmd/unstake.go @@ -4,16 +4,14 @@ package cmd import ( "errors" "math/big" - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/pflag" "github.com/spf13/cobra" @@ -37,36 +35,14 @@ func initialiseUnstake(cmd *cobra.Command, args []string) { //This function sets the flag appropriately and executes the Unstake function func (*UtilsStruct) ExecuteUnstake(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteUnstake: Config: %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) log.Debug("Getting amount in wei...") valueInWei, err := cmdUtils.AssignAmountInWei(flagSet) utils.CheckError("Error in getting amountInWei: ", err) - stakerId, err := razorUtils.AssignStakerId(flagSet, client, address) + stakerId, err := razorUtils.AssignStakerId(rpcParameters, flagSet, account.Address) utils.CheckError("StakerId error: ", err) unstakeInput := types.UnstakeInput{ @@ -75,25 +51,24 @@ func (*UtilsStruct) ExecuteUnstake(flagSet *pflag.FlagSet) { Account: account, } - txnHash, err := cmdUtils.Unstake(config, client, unstakeInput) + txnHash, err := cmdUtils.Unstake(rpcParameters, config, unstakeInput) utils.CheckError("Unstake Error: ", err) if txnHash != core.NilHash { - err = razorUtils.WaitForBlockCompletion(client, txnHash.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txnHash.Hex()) utils.CheckError("Error in WaitForBlockCompletion for unstake: ", err) } } //This function allows user to unstake their sRZRs in the razor network -func (*UtilsStruct) Unstake(config types.Configurations, client *ethclient.Client, input types.UnstakeInput) (common.Hash, error) { +func (*UtilsStruct) Unstake(rpcParameters rpc.RPCParameters, config types.Configurations, input types.UnstakeInput) (common.Hash, error) { txnArgs := types.TransactionOptions{ - Client: client, Amount: input.ValueInWei, ChainId: core.ChainId, Config: config, Account: input.Account, } stakerId := input.StakerId - staker, err := razorUtils.GetStaker(client, stakerId) + staker, err := razorUtils.GetStaker(rpcParameters, stakerId) if err != nil { log.Error("Error in getting staker: ", err) return core.NilHash, err @@ -101,13 +76,13 @@ func (*UtilsStruct) Unstake(config types.Configurations, client *ethclient.Clien log.Debugf("Unstake: Staker info: %+v", staker) log.Debug("Unstake: Calling ApproveUnstake()...") - approveHash, err := cmdUtils.ApproveUnstake(client, staker.TokenAddress, txnArgs) + approveHash, err := cmdUtils.ApproveUnstake(rpcParameters, staker.TokenAddress, txnArgs) if err != nil { return core.NilHash, err } if approveHash != core.NilHash { - err = razorUtils.WaitForBlockCompletion(client, approveHash.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, approveHash.Hex()) if err != nil { return core.NilHash, err } @@ -119,7 +94,7 @@ func (*UtilsStruct) Unstake(config types.Configurations, client *ethclient.Clien txnArgs.MethodName = "unstake" txnArgs.ABI = bindings.StakeManagerMetaData.ABI - unstakeLock, err := razorUtils.GetLock(txnArgs.Client, txnArgs.Account.Address, stakerId, 0) + unstakeLock, err := razorUtils.GetLock(rpcParameters, txnArgs.Account.Address, stakerId, 0) if err != nil { log.Error("Error in getting unstakeLock: ", err) return core.NilHash, err @@ -133,10 +108,18 @@ func (*UtilsStruct) Unstake(config types.Configurations, client *ethclient.Clien } txnArgs.Parameters = []interface{}{stakerId, txnArgs.Amount} - txnOpts := razorUtils.GetTxnOpts(txnArgs) + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) + if err != nil { + return core.NilHash, err + } log.Info("Unstaking coins") + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debugf("Executing Unstake transaction with stakerId = %d, amount = %s", stakerId, txnArgs.Amount) - txn, err := stakeManagerUtils.Unstake(txnArgs.Client, txnOpts, stakerId, txnArgs.Amount) + txn, err := stakeManagerUtils.Unstake(client, txnOpts, stakerId, txnArgs.Amount) if err != nil { log.Error("Error in un-staking: ", err) return core.NilHash, err @@ -147,8 +130,16 @@ func (*UtilsStruct) Unstake(config types.Configurations, client *ethclient.Clien } //This function approves the unstake -func (*UtilsStruct) ApproveUnstake(client *ethclient.Client, stakerTokenAddress common.Address, txnArgs types.TransactionOptions) (common.Hash, error) { - txnOpts := razorUtils.GetTxnOpts(txnArgs) +func (*UtilsStruct) ApproveUnstake(rpcParameters rpc.RPCParameters, stakerTokenAddress common.Address, txnArgs types.TransactionOptions) (common.Hash, error) { + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs) + if err != nil { + return core.NilHash, err + } + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Infof("Approving %d amount for unstake...", txnArgs.Amount) txn, err := stakeManagerUtils.ApproveUnstake(client, txnOpts, stakerTokenAddress, txnArgs.Amount) if err != nil { diff --git a/cmd/unstake_test.go b/cmd/unstake_test.go index 3f8008dfe..ee67b247c 100644 --- a/cmd/unstake_test.go +++ b/cmd/unstake_test.go @@ -4,7 +4,6 @@ import ( "crypto/ecdsa" "crypto/rand" "errors" - "github.com/ethereum/go-ethereum/crypto" "math/big" "razor/accounts" "razor/core" @@ -13,6 +12,8 @@ import ( "reflect" "testing" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" Types "github.com/ethereum/go-ethereum/core/types" @@ -23,7 +24,6 @@ import ( func TestUnstake(t *testing.T) { var config types.Configurations - var client *ethclient.Client var account types.Account var stakerId uint32 @@ -37,6 +37,7 @@ func TestUnstake(t *testing.T) { lockErr error state uint32 stateErr error + txnOptsErr error unstakeTxn *Types.Transaction unstakeErr error hash common.Hash @@ -117,22 +118,33 @@ func TestUnstake(t *testing.T) { }, wantErr: nil, }, + { + name: "Test 9: When there is an error in getting txnOpts", + args: args{ + lock: types.Locks{ + Amount: big.NewInt(0), + }, + amount: big.NewInt(1000), + txnOptsErr: errors.New("txnOpts error"), + }, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetStaker", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.staker, tt.args.stakerErr) - cmdUtilsMock.On("ApproveUnstake", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything).Return(tt.args.approveHash, tt.args.approveHashErr) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) - utilsMock.On("GetLock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string"), mock.AnythingOfType("uint32"), mock.Anything).Return(tt.args.lock, tt.args.lockErr) - cmdUtilsMock.On("WaitForAppropriateState", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.state, tt.args.stateErr) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) + utilsMock.On("GetStaker", mock.Anything, mock.Anything).Return(tt.args.staker, tt.args.stakerErr) + cmdUtilsMock.On("ApproveUnstake", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.approveHash, tt.args.approveHashErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) + utilsMock.On("GetLock", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.lock, tt.args.lockErr) + cmdUtilsMock.On("WaitForAppropriateState", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.state, tt.args.stateErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) stakeManagerMock.On("Unstake", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.unstakeTxn, tt.args.unstakeErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} - _, gotErr := utils.Unstake(config, client, + _, gotErr := utils.Unstake(rpcParameters, config, types.UnstakeInput{ Account: account, StakerId: stakerId, @@ -283,13 +295,16 @@ func TestExecuteUnstake(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("AssignPassword", flagSet).Return(tt.args.password) @@ -298,10 +313,10 @@ func TestExecuteUnstake(t *testing.T) { flagSetMock.On("GetStringAddress", flagSet).Return(tt.args.address, tt.args.addressErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) cmdUtilsMock.On("AssignAmountInWei", flagSet).Return(tt.args.value, tt.args.valueErr) - utilsMock.On("AssignStakerId", flagSet, mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.stakerId, tt.args.stakerIdErr) - utilsMock.On("GetLock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string"), mock.AnythingOfType("uint32")).Return(tt.args.lock, tt.args.lockErr) + utilsMock.On("AssignStakerId", mock.Anything, flagSet, mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) + utilsMock.On("GetLock", mock.Anything, mock.AnythingOfType("string"), mock.AnythingOfType("uint32")).Return(tt.args.lock, tt.args.lockErr) cmdUtilsMock.On("Unstake", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.unstakeHash, tt.args.unstakeErr) - utilsMock.On("WaitForBlockCompletion", client, mock.AnythingOfType("string")).Return(nil) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) utils := &UtilsStruct{} fatal = false @@ -318,7 +333,6 @@ func TestExecuteUnstake(t *testing.T) { func TestApproveUnstake(t *testing.T) { var ( - client *ethclient.Client stakerTokenAddress common.Address txnArgs types.TransactionOptions ) @@ -326,9 +340,10 @@ func TestApproveUnstake(t *testing.T) { privateKey, _ := ecdsa.GenerateKey(crypto.S256(), rand.Reader) txnOpts, _ := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(31337)) type args struct { - txn *Types.Transaction - txnErr error - hash common.Hash + txnOptsErr error + txn *Types.Transaction + txnErr error + hash common.Hash } tests := []struct { name string @@ -345,23 +360,31 @@ func TestApproveUnstake(t *testing.T) { wantErr: false, }, { - name: "Test 1: When there is an error in getting transaction", + name: "Test 2: When there is an error in getting transaction", args: args{ txnErr: errors.New("error in getting transaction"), }, want: core.NilHash, wantErr: true, }, + { + name: "Test 3: When there is an error in getting txnOpts", + args: args{ + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: true, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(txnOpts) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(txnOpts, tt.args.txnOptsErr) stakeManagerMock.On("ApproveUnstake", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.Anything).Return(tt.args.txn, tt.args.txnErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) ut := &UtilsStruct{} - got, err := ut.ApproveUnstake(client, stakerTokenAddress, txnArgs) + got, err := ut.ApproveUnstake(rpcParameters, stakerTokenAddress, txnArgs) if (err != nil) != tt.wantErr { t.Errorf("ApproveUnstake() error = %v, wantErr %v", err, tt.wantErr) return diff --git a/cmd/updateCollection.go b/cmd/updateCollection.go index 10b249064..03a57e7d5 100644 --- a/cmd/updateCollection.go +++ b/cmd/updateCollection.go @@ -2,15 +2,13 @@ package cmd import ( - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/cobra" "github.com/spf13/pflag" ) @@ -36,30 +34,8 @@ func initialiseUpdateCollection(cmd *cobra.Command, args []string) { //This function sets the flag appropriately and executes the UpdateCollection function func (*UtilsStruct) ExecuteUpdateCollection(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteUpdateCollection: Config : %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) collectionId, err := flagSetUtils.GetUint16CollectionId(flagSet) utils.CheckError("Error in getting collectionID: ", err) @@ -83,23 +59,22 @@ func (*UtilsStruct) ExecuteUpdateCollection(flagSet *pflag.FlagSet) { Tolerance: tolerance, Account: account, } - txn, err := cmdUtils.UpdateCollection(client, config, collectionInput, collectionId) + txn, err := cmdUtils.UpdateCollection(rpcParameters, config, collectionInput, collectionId) utils.CheckError("Update Collection error: ", err) - err = razorUtils.WaitForBlockCompletion(client, txn.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txn.Hex()) utils.CheckError("Error in WaitForBlockCompletion for updateCollection: ", err) } //This function allows the admin to update an existing collection -func (*UtilsStruct) UpdateCollection(client *ethclient.Client, config types.Configurations, collectionInput types.CreateCollectionInput, collectionId uint16) (common.Hash, error) { +func (*UtilsStruct) UpdateCollection(rpcParameters rpc.RPCParameters, config types.Configurations, collectionInput types.CreateCollectionInput, collectionId uint16) (common.Hash, error) { jobIds := utils.ConvertUintArrayToUint16Array(collectionInput.JobIds) log.Debug("UpdateCollection: Uint16 jobIds: ", jobIds) - _, err := cmdUtils.WaitIfCommitState(client, "update collection") + _, err := cmdUtils.WaitIfCommitState(rpcParameters, "update collection") if err != nil { log.Error("Error in fetching state") return core.NilHash, err } - txnOpts := razorUtils.GetTxnOpts(types.TransactionOptions{ - Client: client, + txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{ ChainId: core.ChainId, Config: config, ContractAddress: core.CollectionManagerAddress, @@ -108,7 +83,15 @@ func (*UtilsStruct) UpdateCollection(client *ethclient.Client, config types.Conf ABI: bindings.CollectionManagerMetaData.ABI, Account: collectionInput.Account, }) + if err != nil { + return core.NilHash, err + } log.Info("Updating collection...") + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debugf("Executing UpdateCollection transaction with collectionId = %d, tolerance = %d, aggregation method = %d, power = %d, jobIds = %v", collectionId, collectionInput.Tolerance, collectionInput.Aggregation, collectionInput.Power, jobIds) txn, err := assetManagerUtils.UpdateCollection(client, txnOpts, collectionId, collectionInput.Tolerance, collectionInput.Aggregation, collectionInput.Power, jobIds) if err != nil { diff --git a/cmd/updateCollection_test.go b/cmd/updateCollection_test.go index f473a212d..0cf128b54 100644 --- a/cmd/updateCollection_test.go +++ b/cmd/updateCollection_test.go @@ -16,7 +16,6 @@ import ( ) func TestUpdateCollection(t *testing.T) { - var client *ethclient.Client var config types.Configurations var WaitIfCommitStateStatus uint32 var jobIdUint16 []uint16 @@ -24,6 +23,7 @@ func TestUpdateCollection(t *testing.T) { var collectionId uint16 type args struct { + txnOptsErr error updateCollectionTxn *Types.Transaction updateCollectionErr error waitIfCommitStateErr error @@ -69,19 +69,27 @@ func TestUpdateCollection(t *testing.T) { want: core.NilHash, wantErr: errors.New("waitIfCommitState error"), }, + { + name: "Test 4: When there is an error in getting txnOpts", + args: args{ + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() utilsMock.On("ConvertUintArrayToUint16Array", mock.Anything).Return(jobIdUint16) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) - cmdUtilsMock.On("WaitIfCommitState", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(WaitIfCommitStateStatus, tt.args.waitIfCommitStateErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) + cmdUtilsMock.On("WaitIfCommitState", mock.Anything, mock.Anything).Return(WaitIfCommitStateStatus, tt.args.waitIfCommitStateErr) assetManagerMock.On("UpdateCollection", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.updateCollectionTxn, tt.args.updateCollectionErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.UpdateCollection(client, config, collectionInput, collectionId) + got, err := utils.UpdateCollection(rpcParameters, config, collectionInput, collectionId) if got != tt.want { t.Errorf("Txn hash for updateCollection function, got = %v, want = %v", got, tt.want) @@ -266,14 +274,16 @@ func TestExecuteUpdateCollection(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("AssignPassword", flagSet).Return(tt.args.password) @@ -285,8 +295,8 @@ func TestExecuteUpdateCollection(t *testing.T) { flagSetMock.On("GetUint32Aggregation", flagSet).Return(tt.args.aggregation, tt.args.aggregationErr) flagSetMock.On("GetInt8Power", flagSet).Return(tt.args.power, tt.args.powerErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - cmdUtilsMock.On("UpdateCollection", mock.AnythingOfType("*ethclient.Client"), config, mock.Anything, mock.Anything).Return(tt.args.updateCollectionTxn, tt.args.updateCollectionErr) - utilsMock.On("WaitForBlockCompletion", client, mock.AnythingOfType("string")).Return(nil) + cmdUtilsMock.On("UpdateCollection", mock.Anything, config, mock.Anything, mock.Anything).Return(tt.args.updateCollectionTxn, tt.args.updateCollectionErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) flagSetMock.On("GetUint32Tolerance", flagSet).Return(tt.args.tolerance, tt.args.toleranceErr) utils := &UtilsStruct{} diff --git a/cmd/updateCommission.go b/cmd/updateCommission.go index 5c59f15ab..ba7142c8e 100644 --- a/cmd/updateCommission.go +++ b/cmd/updateCommission.go @@ -3,14 +3,12 @@ package cmd import ( "errors" - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/pflag" "github.com/spf13/cobra" @@ -33,35 +31,13 @@ func initialiseUpdateCommission(cmd *cobra.Command, args []string) { //This function sets the flag appropriately and executes the UpdateCommission function func (*UtilsStruct) ExecuteUpdateCommission(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteUpdateCommission: Config: %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) commission, err := flagSetUtils.GetUint8Commission(flagSet) utils.CheckError("Error in getting commission", err) - stakerId, err := razorUtils.GetStakerId(client, address) + stakerId, err := razorUtils.GetStakerId(rpcParameters, account.Address) utils.CheckError("Error in getting stakerId", err) updateCommissionInput := types.UpdateCommissionInput{ @@ -70,20 +46,20 @@ func (*UtilsStruct) ExecuteUpdateCommission(flagSet *pflag.FlagSet) { Account: account, } - err = cmdUtils.UpdateCommission(config, client, updateCommissionInput) + err = cmdUtils.UpdateCommission(rpcParameters, config, updateCommissionInput) utils.CheckError("UpdateCommission error: ", err) } //This function allows a staker to add/update the commission value -func (*UtilsStruct) UpdateCommission(config types.Configurations, client *ethclient.Client, updateCommissionInput types.UpdateCommissionInput) error { - stakerInfo, err := razorUtils.GetStaker(client, updateCommissionInput.StakerId) +func (*UtilsStruct) UpdateCommission(rpcParameters rpc.RPCParameters, config types.Configurations, updateCommissionInput types.UpdateCommissionInput) error { + stakerInfo, err := razorUtils.GetStaker(rpcParameters, updateCommissionInput.StakerId) if err != nil { log.Error("Error in fetching staker info") return err } log.Debugf("UpdateCommission: Staker Info: %+v", stakerInfo) - maxCommission, err := razorUtils.GetMaxCommission(client) + maxCommission, err := razorUtils.GetMaxCommission(rpcParameters) if err != nil { return err } @@ -93,13 +69,13 @@ func (*UtilsStruct) UpdateCommission(config types.Configurations, client *ethcli return errors.New("commission out of range") } - epochLimitForUpdateCommission, err := razorUtils.GetEpochLimitForUpdateCommission(client) + epochLimitForUpdateCommission, err := razorUtils.GetEpochLimitForUpdateCommission(rpcParameters) if err != nil { return err } log.Debug("UpdateCommission: Epoch limit to update commission: ", epochLimitForUpdateCommission) - epoch, err := razorUtils.GetEpoch(client) + epoch, err := razorUtils.GetEpoch(rpcParameters) if err != nil { return err } @@ -117,7 +93,6 @@ func (*UtilsStruct) UpdateCommission(config types.Configurations, client *ethcli return errors.New("invalid epoch for update") } txnOpts := types.TransactionOptions{ - Client: client, ChainId: core.ChainId, Config: config, ContractAddress: core.StakeManagerAddress, @@ -126,8 +101,16 @@ func (*UtilsStruct) UpdateCommission(config types.Configurations, client *ethcli Parameters: []interface{}{updateCommissionInput.Commission}, Account: updateCommissionInput.Account, } - updateCommissionTxnOpts := razorUtils.GetTxnOpts(txnOpts) + updateCommissionTxnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnOpts) + if err != nil { + return err + } log.Infof("Setting the commission value of Staker %d to %d%%", updateCommissionInput.StakerId, updateCommissionInput.Commission) + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return err + } + log.Debug("Executing UpdateCommission transaction with commission = ", updateCommissionInput.Commission) txn, err := stakeManagerUtils.UpdateCommission(client, updateCommissionTxnOpts, updateCommissionInput.Commission) if err != nil { @@ -136,7 +119,7 @@ func (*UtilsStruct) UpdateCommission(config types.Configurations, client *ethcli } txnHash := transactionUtils.Hash(txn) log.Infof("Txn Hash: %s", txnHash.Hex()) - err = razorUtils.WaitForBlockCompletion(client, txnHash.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txnHash.Hex()) if err != nil { log.Error("Error in WaitForBlockCompletion for updateCommission: ", err) return err diff --git a/cmd/updateCommission_test.go b/cmd/updateCommission_test.go index 79dbeecd7..e65d1b4e2 100644 --- a/cmd/updateCommission_test.go +++ b/cmd/updateCommission_test.go @@ -15,7 +15,6 @@ import ( ) func TestUpdateCommission(t *testing.T) { - var client *ethclient.Client var config = types.Configurations{ Provider: "127.0.0.1", GasMultiplier: 1, @@ -34,6 +33,7 @@ func TestUpdateCommission(t *testing.T) { epoch uint32 epochErr error time string + txnOptsErr error UpdateCommissionTxn *Types.Transaction UpdateCommissionErr error hash common.Hash @@ -185,23 +185,35 @@ func TestUpdateCommission(t *testing.T) { }, wantErr: errors.New("invalid epoch for update"), }, + { + name: "Test 11: When there is an error in getting txnOpts", + args: args{ + commission: 10, + stakerInfo: bindings.StructsStaker{}, + maxCommission: 20, + epochLimitForUpdateCommission: 10, + epoch: 11, + txnOptsErr: errors.New("txnOpts error"), + }, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetStaker", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.stakerInfo, tt.args.stakerInfoErr) - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) - utilsMock.On("GetEpoch", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epoch, tt.args.epochErr) + utilsMock.On("GetStaker", mock.Anything, mock.Anything).Return(tt.args.stakerInfo, tt.args.stakerInfoErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) + utilsMock.On("GetEpoch", mock.Anything).Return(tt.args.epoch, tt.args.epochErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) - utilsMock.On("GetMaxCommission", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.maxCommission, tt.args.maxCommissionErr) - utilsMock.On("GetEpochLimitForUpdateCommission", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epochLimitForUpdateCommission, tt.args.epochLimitForUpdateCommissionErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) + utilsMock.On("GetMaxCommission", mock.Anything, mock.Anything).Return(tt.args.maxCommission, tt.args.maxCommissionErr) + utilsMock.On("GetEpochLimitForUpdateCommission", mock.Anything).Return(tt.args.epochLimitForUpdateCommission, tt.args.epochLimitForUpdateCommissionErr) utilsMock.On("SecondsToReadableTime", mock.AnythingOfType("int")).Return(tt.args.time) stakeManagerMock.On("UpdateCommission", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.UpdateCommissionTxn, tt.args.UpdateCommissionErr) utils := &UtilsStruct{} - gotErr := utils.UpdateCommission(config, client, types.UpdateCommissionInput{ + gotErr := utils.UpdateCommission(rpcParameters, config, types.UpdateCommissionInput{ Commission: tt.args.commission, }) if gotErr == nil || tt.wantErr == nil { @@ -323,14 +335,16 @@ func TestExecuteUpdateCommission(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) flagSetMock.On("GetStringAddress", flagSet).Return(tt.args.address, tt.args.addressErr) @@ -338,7 +352,7 @@ func TestExecuteUpdateCommission(t *testing.T) { utilsMock.On("CheckPassword", mock.Anything).Return(nil) utilsMock.On("AccountManagerForKeystore").Return(&accounts.AccountManager{}, nil) flagSetMock.On("GetUint8Commission", flagSet).Return(tt.args.commission, tt.args.commissionErr) - utilsMock.On("GetStakerId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.stakerId, tt.args.stakerIdErr) + utilsMock.On("GetStakerId", mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) cmdUtilsMock.On("UpdateCommission", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.UpdateCommissionErr) diff --git a/cmd/updateJob.go b/cmd/updateJob.go index a1cbe352d..d4c24dd49 100644 --- a/cmd/updateJob.go +++ b/cmd/updateJob.go @@ -2,15 +2,13 @@ package cmd import ( - "razor/accounts" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/cobra" "github.com/spf13/pflag" ) @@ -36,30 +34,8 @@ func initialiseUpdateJob(cmd *cobra.Command, args []string) { //This function sets the flag appropriately and executes the UpdateJob function func (*UtilsStruct) ExecuteUpdateJob(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteUpdateJob: Config: %+v", config) - - client := razorUtils.ConnectToClient(config.Provider) - - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) + config, rpcParameters, _, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) jobId, err := flagSetUtils.GetUint16JobId(flagSet) utils.CheckError("Error in getting jobId: ", err) @@ -88,21 +64,20 @@ func (*UtilsStruct) ExecuteUpdateJob(flagSet *pflag.FlagSet) { Account: account, } - txn, err := cmdUtils.UpdateJob(client, config, jobInput, jobId) + txn, err := cmdUtils.UpdateJob(rpcParameters, config, jobInput, jobId) utils.CheckError("UpdateJob error: ", err) - err = razorUtils.WaitForBlockCompletion(client, txn.Hex()) + err = razorUtils.WaitForBlockCompletion(rpcParameters, txn.Hex()) utils.CheckError("Error in WaitForBlockCompletion for updateJob: ", err) } //This function allows the admin to update an existing job -func (*UtilsStruct) UpdateJob(client *ethclient.Client, config types.Configurations, jobInput types.CreateJobInput, jobId uint16) (common.Hash, error) { - _, err := cmdUtils.WaitIfCommitState(client, "update job") +func (*UtilsStruct) UpdateJob(rpcParameters rpc.RPCParameters, config types.Configurations, jobInput types.CreateJobInput, jobId uint16) (common.Hash, error) { + _, err := cmdUtils.WaitIfCommitState(rpcParameters, "update job") if err != nil { log.Error("Error in fetching state") return core.NilHash, err } - txnArgs := razorUtils.GetTxnOpts(types.TransactionOptions{ - Client: client, + txnArgs, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{ ChainId: core.ChainId, Config: config, ContractAddress: core.CollectionManagerAddress, @@ -111,7 +86,15 @@ func (*UtilsStruct) UpdateJob(client *ethclient.Client, config types.Configurati ABI: bindings.CollectionManagerMetaData.ABI, Account: jobInput.Account, }) + if err != nil { + return core.NilHash, err + } log.Info("Updating Job...") + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return core.NilHash, err + } + log.Debugf("Executing UpdateJob transaction with arguments jobId = %d, weight = %d, power = %d, selector type = %d, selector = %s, URL = %s", jobId, jobInput.Weight, jobInput.Power, jobInput.SelectorType, jobInput.Selector, jobInput.Url) txn, err := assetManagerUtils.UpdateJob(client, txnArgs, jobId, jobInput.Weight, jobInput.Power, jobInput.SelectorType, jobInput.Selector, jobInput.Url) if err != nil { diff --git a/cmd/updateJob_test.go b/cmd/updateJob_test.go index 0d2da59a7..6452c83a5 100644 --- a/cmd/updateJob_test.go +++ b/cmd/updateJob_test.go @@ -16,14 +16,13 @@ import ( ) func TestUpdateJob(t *testing.T) { - - var client *ethclient.Client var config types.Configurations var WaitIfCommitStateStatus uint32 var jobInput types.CreateJobInput var jobId uint16 type args struct { + txnOptsErr error updateJobTxn *Types.Transaction updateJobErr error waitIfCommitStateErr error @@ -64,19 +63,27 @@ func TestUpdateJob(t *testing.T) { want: core.NilHash, wantErr: errors.New("waitIfCommitState error"), }, + { + name: "Test 4: When there is an error in getting txnOpts", + args: args{ + txnOptsErr: errors.New("txnOpts error"), + }, + want: core.NilHash, + wantErr: errors.New("txnOpts error"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(TxnOpts) - cmdUtilsMock.On("WaitIfCommitState", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(WaitIfCommitStateStatus, tt.args.waitIfCommitStateErr) + utilsMock.On("GetTxnOpts", mock.Anything, mock.Anything).Return(TxnOpts, tt.args.txnOptsErr) + cmdUtilsMock.On("WaitIfCommitState", mock.Anything, mock.Anything, mock.Anything).Return(WaitIfCommitStateStatus, tt.args.waitIfCommitStateErr) assetManagerMock.On("UpdateJob", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.TransactOpts"), mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.updateJobTxn, tt.args.updateJobErr) transactionMock.On("Hash", mock.Anything).Return(tt.args.hash) utils := &UtilsStruct{} - got, err := utils.UpdateJob(client, config, jobInput, jobId) + got, err := utils.UpdateJob(rpcParameters, config, jobInput, jobId) if got != tt.want { t.Errorf("Txn hash for updateJob function, got = %v, want = %v", got, tt.want) } @@ -313,14 +320,16 @@ func TestExecuteUpdateJob(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("AssignPassword", flagSet).Return(tt.args.password) @@ -334,8 +343,8 @@ func TestExecuteUpdateJob(t *testing.T) { flagSetMock.On("GetUint8Weight", flagSet).Return(tt.args.weight, tt.args.weightErr) flagSetMock.On("GetUint8SelectorType", flagSet).Return(tt.args.selectorType, tt.args.selectorTypeErr) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) - cmdUtilsMock.On("UpdateJob", mock.AnythingOfType("*ethclient.Client"), config, mock.Anything, mock.Anything).Return(tt.args.updateJobTxn, tt.args.updateJobErr) - utilsMock.On("WaitForBlockCompletion", client, mock.AnythingOfType("string")).Return(nil) + cmdUtilsMock.On("UpdateJob", mock.Anything, config, mock.Anything, mock.Anything).Return(tt.args.updateJobTxn, tt.args.updateJobErr) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) utils := &UtilsStruct{} fatal = false diff --git a/cmd/vote.go b/cmd/vote.go index 0dd69073a..608b7e2a0 100644 --- a/cmd/vote.go +++ b/cmd/vote.go @@ -10,12 +10,12 @@ import ( "os" "os/signal" "path/filepath" - "razor/accounts" + "razor/block" "razor/cache" "razor/core" "razor/core/types" - "razor/logger" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "time" @@ -26,7 +26,6 @@ import ( "github.com/spf13/pflag" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" solsha3 "github.com/miguelmota/go-solidity-sha3" "github.com/spf13/cobra" ) @@ -48,35 +47,12 @@ func initializeVote(cmd *cobra.Command, args []string) { //This function sets the flag appropriately and executes the Vote function func (*UtilsStruct) ExecuteVote(flagSet *pflag.FlagSet) { - config, err := cmdUtils.GetConfigData() - utils.CheckError("Error in getting config: ", err) - log.Debugf("ExecuteVote: Config: %+v", config) + config, rpcParameters, blockMonitor, account, err := InitializeCommandDependencies(flagSet) + utils.CheckError("Error in initialising command dependencies: ", err) - client := razorUtils.ConnectToClient(config.Provider) - - err = ValidateBufferPercentLimit(client, config.BufferPercent) + err = ValidateBufferPercentLimit(rpcParameters, config.BufferPercent) utils.CheckError("Error in validating buffer percent: ", err) - address, err := flagSetUtils.GetStringAddress(flagSet) - utils.CheckError("Error in getting address: ", err) - log.Debug("ExecuteVote: Address: ", address) - - logger.SetLoggerParameters(client, address) - - log.Debug("Checking to assign log file...") - fileUtils.AssignLogFile(flagSet, config) - - log.Debug("Getting password...") - password := razorUtils.AssignPassword(flagSet) - - accountManager, err := razorUtils.AccountManagerForKeystore() - utils.CheckError("Error in getting accounts manager for keystore: ", err) - - account := accounts.InitAccountStruct(address, password, accountManager) - - err = razorUtils.CheckPassword(account) - utils.CheckError("Error in fetching private key from given password: ", err) - isRogue, err := flagSetUtils.GetBoolRogue(flagSet) utils.CheckError("Error in getting rogue status: ", err) log.Debug("ExecuteVote: IsRogue: ", isRogue) @@ -106,7 +82,7 @@ func (*UtilsStruct) ExecuteVote(flagSet *pflag.FlagSet) { }, } - stakerId, err := razorUtils.GetStakerId(client, address) + stakerId, err := razorUtils.GetStakerId(rpcParameters, account.Address) utils.CheckError("Error in getting staker id: ", err) if stakerId == 0 { @@ -115,7 +91,7 @@ func (*UtilsStruct) ExecuteVote(flagSet *pflag.FlagSet) { cmdUtils.HandleExit() - jobsCache, collectionsCache, initCacheBlockNumber, err := cmdUtils.InitJobAndCollectionCache(client) + jobsCache, collectionsCache, initCacheBlockNumber, err := cmdUtils.InitJobAndCollectionCache(rpcParameters) utils.CheckError("Error in initializing asset cache: ", err) commitParams := &types.CommitParams{ @@ -127,7 +103,7 @@ func (*UtilsStruct) ExecuteVote(flagSet *pflag.FlagSet) { } log.Debugf("Calling Vote() with arguments rogueData = %+v, account address = %s, backup node actions to ignore = %s", rogueData, account.Address, backupNodeActionsToIgnore) - if err := cmdUtils.Vote(context.Background(), config, client, account, stakerId, commitParams, rogueData, backupNodeActionsToIgnore); err != nil { + if err := cmdUtils.Vote(rpcParameters, blockMonitor, config, account, stakerId, commitParams, rogueData, backupNodeActionsToIgnore); err != nil { log.Errorf("%v\n", err) osUtils.Exit(1) } @@ -158,24 +134,24 @@ func (*UtilsStruct) HandleExit() { } //This function handles all the states of voting -func (*UtilsStruct) Vote(ctx context.Context, config types.Configurations, client *ethclient.Client, account types.Account, stakerId uint32, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) error { - header, err := clientUtils.GetLatestBlockWithRetry(client) +func (*UtilsStruct) Vote(rpcParameters rpc.RPCParameters, blockMonitor *block.BlockMonitor, config types.Configurations, account types.Account, stakerId uint32, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) error { + header, err := clientUtils.GetLatestBlockWithRetry(rpcParameters) utils.CheckError("Error in getting block: ", err) for { select { - case <-ctx.Done(): + case <-rpcParameters.Ctx.Done(): return nil default: log.Debugf("Vote: Header value: %d", header.Number) - latestHeader, err := clientUtils.GetLatestBlockWithRetry(client) - if err != nil { - log.Error("Error in fetching block: ", err) + latestHeader := blockMonitor.GetLatestBlock() + if latestHeader == nil { + log.Error("Block monitor returned nil header") continue } log.Debugf("Vote: Latest header value: %d", latestHeader.Number) if latestHeader.Number.Cmp(header.Number) != 0 { header = latestHeader - cmdUtils.HandleBlock(client, account, stakerId, latestHeader, config, commitParams, rogueData, backupNodeActionsToIgnore) + cmdUtils.HandleBlock(rpcParameters, account, stakerId, latestHeader, config, commitParams, rogueData, backupNodeActionsToIgnore) } time.Sleep(time.Second * time.Duration(core.BlockNumberInterval)) } @@ -187,37 +163,58 @@ var ( lastVerification uint32 blockConfirmed uint32 disputeData types.DisputeFileData + lastRPCRefreshEpoch uint32 ) //This function handles the block -func (*UtilsStruct) HandleBlock(client *ethclient.Client, account types.Account, stakerId uint32, latestHeader *Types.Header, config types.Configurations, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) { - state, err := razorUtils.GetBufferedState(client, latestHeader, config.BufferPercent) +func (*UtilsStruct) HandleBlock(rpcParameters rpc.RPCParameters, account types.Account, stakerId uint32, latestHeader *Types.Header, config types.Configurations, commitParams *types.CommitParams, rogueData types.Rogue, backupNodeActionsToIgnore []string) { + stateBuffer, err := razorUtils.GetStateBuffer(rpcParameters) + if err != nil { + log.Error("Error in getting state buffer: ", err) + return + } + remainingTimeOfTheCurrentState, err := razorUtils.GetRemainingTimeOfCurrentState(latestHeader, stateBuffer, config.BufferPercent) + if err != nil { + log.Error("Error in getting remaining time of the current state: ", err) + return + } + if remainingTimeOfTheCurrentState <= 0 { + return + } + + ctx, cancel := context.WithTimeout(context.Background(), time.Duration(remainingTimeOfTheCurrentState)*time.Second) + defer cancel() + + // Replacing context with the context which timeouts after remainingTimeOfTheCurrentState seconds + rpcParameters.Ctx = ctx + + state, err := razorUtils.GetBufferedState(latestHeader, stateBuffer, config.BufferPercent) if err != nil { log.Error("Error in getting state: ", err) return } - epoch, err := razorUtils.GetEpoch(client) + epoch, err := razorUtils.GetEpoch(rpcParameters) if err != nil { log.Error("Error in getting epoch: ", err) return } - staker, err := razorUtils.GetStaker(client, stakerId) + staker, err := razorUtils.GetStaker(rpcParameters, stakerId) if err != nil { log.Error(err) return } stakedAmount := staker.Stake - ethBalance, err := clientUtils.BalanceAtWithRetry(client, common.HexToAddress(account.Address)) + ethBalance, err := clientUtils.BalanceAtWithRetry(rpcParameters, common.HexToAddress(account.Address)) if err != nil { log.Errorf("Error in fetching balance of the account: %s\n%v", account.Address, err) return } - // Warning the staker if ETH balance is less than 0.1 ETH - if ethBalance.Cmp(big.NewInt(1e17)) == -1 { - log.Warn("sFuel balance is lower than 0.1 SKL, kindly add more SKL to be safe for executing transactions successfully") + // Warning the staker if sFUEL balance is less than 0.001 sFUEL + if ethBalance.Cmp(big.NewInt(1e15)) == -1 { + log.Warn("sFUEL balance is lower than 0.001 sFUEL, kindly add more sFUEL to be safe for executing transactions successfully") } actualStake, err := utils.ConvertWeiToEth(stakedAmount) @@ -231,7 +228,7 @@ func (*UtilsStruct) HandleBlock(client *ethclient.Client, account types.Account, return } - sRZRBalance, err := razorUtils.GetStakerSRZRBalance(client, staker) + sRZRBalance, err := razorUtils.GetStakerSRZRBalance(rpcParameters, staker) if err != nil { log.Error("Error in getting sRZR balance for staker: ", err) return @@ -248,7 +245,7 @@ func (*UtilsStruct) HandleBlock(client *ethclient.Client, account types.Account, } } - log.Infof("State: %s Staker ID: %d Stake: %f sRZR Balance: %f sFuel Balance: %f", utils.GetStateName(state), stakerId, actualStake, sRZRInEth, actualBalance) + log.Infof("State: %s Staker ID: %d Stake: %f sRZR Balance: %f sFUEL Balance: %f", utils.GetStateName(state), stakerId, actualStake, sRZRInEth, actualBalance) if staker.IsSlashed { log.Error("Staker is slashed.... cannot continue to vote!") @@ -258,21 +255,21 @@ func (*UtilsStruct) HandleBlock(client *ethclient.Client, account types.Account, switch state { case 0: log.Debugf("Starting commit...") - err := cmdUtils.InitiateCommit(client, config, account, epoch, stakerId, latestHeader, commitParams, rogueData) + err := cmdUtils.InitiateCommit(rpcParameters, config, account, epoch, stakerId, latestHeader, commitParams, stateBuffer, rogueData) if err != nil { log.Error(err) break } case 1: log.Debugf("Starting reveal...") - err := cmdUtils.InitiateReveal(client, config, account, epoch, staker, latestHeader, rogueData) + err := cmdUtils.InitiateReveal(rpcParameters, config, account, epoch, staker, latestHeader, stateBuffer, rogueData) if err != nil { log.Error(err) break } case 2: log.Debugf("Starting propose...") - err := cmdUtils.InitiatePropose(client, config, account, epoch, staker, latestHeader, rogueData) + err := cmdUtils.InitiatePropose(rpcParameters, config, account, epoch, staker, latestHeader, stateBuffer, rogueData) if err != nil { log.Error(err) break @@ -285,7 +282,7 @@ func (*UtilsStruct) HandleBlock(client *ethclient.Client, account types.Account, break } - err := cmdUtils.HandleDispute(client, config, account, epoch, latestHeader.Number, rogueData, backupNodeActionsToIgnore) + err := cmdUtils.HandleDispute(rpcParameters, config, account, epoch, latestHeader.Number, rogueData, backupNodeActionsToIgnore) if err != nil { log.Error(err) break @@ -295,7 +292,7 @@ func (*UtilsStruct) HandleBlock(client *ethclient.Client, account types.Account, if razorUtils.IsFlagPassed("autoClaimBounty") { log.Debugf("Automatically claiming bounty") - err = cmdUtils.HandleClaimBounty(client, config, account) + err = cmdUtils.HandleClaimBounty(rpcParameters, config, account) if err != nil { log.Error(err) break @@ -305,9 +302,25 @@ func (*UtilsStruct) HandleBlock(client *ethclient.Client, account types.Account, case 4: log.Debugf("Last verification: %d", lastVerification) log.Debugf("Block confirmed: %d", blockConfirmed) - if lastVerification == epoch && blockConfirmed < epoch { - txn, err := cmdUtils.ClaimBlockReward(types.TransactionOptions{ - Client: client, + + if blockConfirmed >= epoch { + log.Debug("Block is already confirmed for this epoch!") + break + } + + confirmedBlock, err := razorUtils.GetConfirmedBlocks(rpcParameters, epoch) + if err != nil { + log.Error(err) + break + } + + if confirmedBlock.ProposerId != 0 { + log.Infof("Block is already confirmed, setting blockConfirmed (%d) to current epoch (%d)", blockConfirmed, epoch) + blockConfirmed = epoch + break + } + if (lastVerification == epoch || lastVerification == 0) && blockConfirmed < epoch { + txn, err := cmdUtils.ClaimBlockReward(rpcParameters, types.TransactionOptions{ ChainId: core.ChainId, Config: config, ContractAddress: core.BlockManagerAddress, @@ -321,12 +334,23 @@ func (*UtilsStruct) HandleBlock(client *ethclient.Client, account types.Account, break } if txn != core.NilHash { - waitForBlockCompletionErr := razorUtils.WaitForBlockCompletion(client, txn.Hex()) - if waitForBlockCompletionErr != nil { - log.Error("Error in WaitForBlockCompletion for claimBlockReward: ", err) + log.Info("Confirm Transaction Hash: ", txn) + } + + if lastRPCRefreshEpoch < epoch { + err = rpcParameters.RPCManager.RefreshEndpoints() + if err != nil { + log.Error("Error in refreshing RPC endpoints: ", err) + break + } + bestEndpointURL, err := rpcParameters.RPCManager.GetBestEndpointURL() + if err != nil { + log.Error("Error in getting best RPC endpoint URL after refreshing: ", err) break } - blockConfirmed = epoch + log.Info("Current best RPC endpoint URL: ", bestEndpointURL) + + lastRPCRefreshEpoch = epoch } } case -1: @@ -340,32 +364,33 @@ func (*UtilsStruct) HandleBlock(client *ethclient.Client, account types.Account, } //This function initiates the commit -func (*UtilsStruct) InitiateCommit(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, stakerId uint32, latestHeader *Types.Header, commitParams *types.CommitParams, rogueData types.Rogue) error { - lastCommit, err := razorUtils.GetEpochLastCommitted(client, stakerId) +func (*UtilsStruct) InitiateCommit(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, stakerId uint32, latestHeader *Types.Header, commitParams *types.CommitParams, stateBuffer uint64, rogueData types.Rogue) error { + lastCommit, err := razorUtils.GetEpochLastCommitted(rpcParameters, stakerId) if err != nil { return errors.New("Error in fetching last commit: " + err.Error()) } log.Debug("InitiateCommit: Epoch last committed: ", lastCommit) if lastCommit >= epoch { - log.Debugf("Cannot commit in epoch %d because last committed epoch is %d", epoch, lastCommit) + // Clearing up the cache storing API results as the staker has already committed successfully + commitParams.LocalCache.ClearAll() return nil } - err = CheckForJobAndCollectionEvents(client, commitParams) + err = CheckForJobAndCollectionEvents(rpcParameters, commitParams) if err != nil { log.Error("Error in checking for asset events: ", err) return err } - staker, err := razorUtils.GetStaker(client, stakerId) + staker, err := razorUtils.GetStaker(rpcParameters, stakerId) if err != nil { log.Error(err) return err } log.Debug("InitiateCommit: Staker:", staker) stakedAmount := staker.Stake - minStakeAmount, err := razorUtils.GetMinStakeAmount(client) + minStakeAmount, err := razorUtils.GetMinStakeAmount(rpcParameters) if err != nil { log.Error("Error in getting minimum stake amount: ", err) return err @@ -383,23 +408,29 @@ func (*UtilsStruct) InitiateCommit(client *ethclient.Client, config types.Config keystorePath := filepath.Join(razorPath, "keystore_files") log.Debugf("InitiateCommit: Keystore file path: %s", keystorePath) log.Debugf("InitiateCommit: Calling CalculateSeed() with arguments keystorePath = %s, epoch = %d", keystorePath, epoch) - seed, err := CalculateSeed(client, account, keystorePath, epoch) + seed, err := CalculateSeed(rpcParameters, account, keystorePath, epoch) if err != nil { return errors.New("Error in getting seed: " + err.Error()) } log.Debugf("InitiateCommit: Calling HandleCommitState with arguments epoch = %d, seed = %v, rogueData = %+v", epoch, seed, rogueData) - commitData, err := cmdUtils.HandleCommitState(client, epoch, seed, commitParams, rogueData) + commitData, err := cmdUtils.HandleCommitState(rpcParameters, epoch, seed, commitParams, rogueData) if err != nil { return errors.New("Error in getting active assets: " + err.Error()) } log.Debug("InitiateCommit: Commit Data: ", commitData) - commitTxn, err := cmdUtils.Commit(client, config, account, epoch, latestHeader, seed, commitData.Leaves) + commitmentToSend, err := CalculateCommitment(seed, commitData.Leaves) + if err != nil { + log.Error("Error in getting commitment: ", err) + return err + } + + commitTxn, err := cmdUtils.Commit(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitmentToSend) if err != nil { return errors.New("Error in committing data: " + err.Error()) } - log.Debug("InitiateCommit: Commit Transaction Hash: ", commitTxn) + log.Info("InitiateCommit: Commit Transaction Hash: ", commitTxn) if commitTxn != core.NilHash { log.Debug("Saving committed data for recovery...") fileName, err := pathUtils.GetCommitDataFileName(account.Address) @@ -408,33 +439,24 @@ func (*UtilsStruct) InitiateCommit(client *ethclient.Client, config types.Config } log.Debug("InitiateCommit: Commit data file path: ", fileName) - err = fileUtils.SaveDataToCommitJsonFile(fileName, epoch, commitData) + err = fileUtils.SaveDataToCommitJsonFile(fileName, epoch, commitData, commitmentToSend) if err != nil { return errors.New("Error in saving data to file" + fileName + ": " + err.Error()) } log.Debug("Data saved!") - log.Debug("Checking for commit transaction status with transaction hash: ", commitTxn) - waitForBlockCompletionErr := razorUtils.WaitForBlockCompletion(client, commitTxn.Hex()) - if waitForBlockCompletionErr != nil { - log.Error("Error in WaitForBlockCompletion for commit: ", waitForBlockCompletionErr) - return errors.New("error in sending commit transaction") - } log.Debug("Updating GlobalCommitDataStruct with latest commitData and epoch...") - updateGlobalCommitDataStruct(commitData, epoch) + updateGlobalCommitDataStruct(commitData, commitmentToSend, epoch) log.Debugf("InitiateCommit: Global commit data struct: %+v", globalCommitDataStruct) - - log.Debug("Clearing up the cache storing API results after successful commit...") - commitParams.LocalCache.ClearAll() } return nil } //This function initiates the reveal -func (*UtilsStruct) InitiateReveal(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *Types.Header, rogueData types.Rogue) error { +func (*UtilsStruct) InitiateReveal(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *Types.Header, stateBuffer uint64, rogueData types.Rogue) error { stakedAmount := staker.Stake log.Debug("InitiateReveal: Staked Amount: ", stakedAmount) - minStakeAmount, err := razorUtils.GetMinStakeAmount(client) + minStakeAmount, err := razorUtils.GetMinStakeAmount(rpcParameters) if err != nil { log.Error("Error in getting minimum stake amount: ", err) return err @@ -444,7 +466,7 @@ func (*UtilsStruct) InitiateReveal(client *ethclient.Client, config types.Config log.Error("Stake is below minimum required. Kindly add stake to continue voting.") return nil } - lastReveal, err := razorUtils.GetEpochLastRevealed(client, staker.Id) + lastReveal, err := razorUtils.GetEpochLastRevealed(rpcParameters, staker.Id) if err != nil { return errors.New("Error in fetching last reveal: " + err.Error()) } @@ -456,115 +478,54 @@ func (*UtilsStruct) InitiateReveal(client *ethclient.Client, config types.Config } log.Debugf("InitiateReveal: Calling CheckForLastCommitted with arguments staker = %+v, epoch = %d", staker, epoch) - if err := cmdUtils.CheckForLastCommitted(client, staker, epoch); err != nil { + if err := cmdUtils.CheckForLastCommitted(rpcParameters, staker, epoch); err != nil { log.Error(err) return err } - if globalCommitDataStruct.Epoch != epoch { - log.Debugf("InitiateReveal: Epoch in global commit data: %v is not equal to current epoch: %v", globalCommitDataStruct.Epoch, epoch) - log.Info("Getting the commit data from file...") - fileName, err := pathUtils.GetCommitDataFileName(account.Address) - if err != nil { - log.Error("Error in getting file name to save committed data: ", err) - return err - } - log.Debug("InitiateReveal: Commit data file path: ", fileName) - committedDataFromFile, err := fileUtils.ReadFromCommitJsonFile(fileName) - if err != nil { - log.Errorf("Error in getting committed data from file %s: %v", fileName, err) - return err - } - log.Debug("InitiateReveal: Committed data from file: ", committedDataFromFile) - if committedDataFromFile.Epoch != epoch { - log.Errorf("File %s doesn't contain latest committed data", fileName) - return errors.New("commit data file doesn't contain latest committed data") - } - log.Debug("Verifying commit data from file...") - razorPath, err := pathUtils.GetDefaultPath() - if err != nil { - return err - } - log.Debugf("InitiateReveal: .razor directory path: %s", razorPath) - keystorePath := filepath.Join(razorPath, "keystore_files") - log.Debugf("InitiateReveal: Keystore file path: %s", keystorePath) + razorPath, err := pathUtils.GetDefaultPath() + if err != nil { + return err + } + log.Debugf("InitiateReveal: .razor directory path: %s", razorPath) + keystorePath := filepath.Join(razorPath, "keystore_files") + log.Debugf("InitiateReveal: Keystore file path: %s", keystorePath) - log.Debugf("InitiateReveal: Calling VerifyCommitment() for address %v with arguments epoch = %v, values = %v", account.Address, epoch, committedDataFromFile.Leaves) - isCommittedDataFromFileValid, err := VerifyCommitment(client, account, keystorePath, epoch, committedDataFromFile.Leaves) - if err != nil { - log.Error("Error in verifying commitment for commit data from file: ", err) - return err - } - if !isCommittedDataFromFileValid { - log.Infof("Not using data from file! as commitment calculated for data from commit data file is not equal to staker's commitment for this epoch.") - return errors.New("commitment verification for commit file data failed") - } - log.Debug("Updating global commit data struct...") - updateGlobalCommitDataStruct(types.CommitData{ - Leaves: committedDataFromFile.Leaves, - SeqAllottedCollections: committedDataFromFile.SeqAllottedCollections, - AssignedCollections: committedDataFromFile.AssignedCollections, - }, epoch) - log.Debugf("InitiateReveal: Global Commit data struct: %+v", globalCommitDataStruct) - } - if rogueData.IsRogue && utils.Contains(rogueData.RogueMode, "reveal") { - log.Warn("YOU ARE REVEALING VALUES IN ROGUE MODE, THIS CAN INCUR PENALTIES!") - var rogueCommittedData []*big.Int - for i := 0; i < len(globalCommitDataStruct.Leaves); i++ { - rogueCommittedData = append(rogueCommittedData, razorUtils.GetRogueRandomValue(10000000)) - } - globalCommitDataStruct.Leaves = rogueCommittedData - log.Debugf("InitiateReveal: Global Commit data struct in rogue mode: %+v", globalCommitDataStruct) + // Consolidated commitment verification for commit data being fetched from memory or file + commitData, err := GetCommittedDataForEpoch(rpcParameters, account, epoch, rogueData) + if err != nil { + return err } - if globalCommitDataStruct.Epoch == epoch { - razorPath, err := pathUtils.GetDefaultPath() - if err != nil { - return err - } - log.Debug("InitiateReveal: .razor directory path: ", razorPath) - keystorePath := filepath.Join(razorPath, "keystore_files") - log.Debug("InitiateReveal: Keystore file path: ", keystorePath) + log.Debugf("InitiateReveal: Calling CalculateSecret() with argument epoch = %d, keystorePath = %s, chainId = %s", epoch, keystorePath, core.ChainId) + signature, _, err := cmdUtils.CalculateSecret(account, epoch, keystorePath, core.ChainId) + if err != nil { + return err + } + log.Debug("InitiateReveal: Signature: ", signature) + log.Debug("InitiateReveal: Assigned Collections: ", commitData.AssignedCollections) + log.Debug("InitiateReveal: SeqAllottedCollections: ", commitData.SeqAllottedCollections) + log.Debug("InitiateReveal: Leaves: ", commitData.Leaves) - log.Debugf("InitiateReveal: Calling CalculateSecret() with argument epoch = %d, keystorePath = %s, chainId = %s", epoch, keystorePath, core.ChainId) - signature, _, err := cmdUtils.CalculateSecret(account, epoch, keystorePath, core.ChainId) - if err != nil { - return err - } - log.Debug("InitiateReveal: Signature: ", signature) - log.Debug("InitiateReveal: Assigned Collections: ", globalCommitDataStruct.AssignedCollections) - log.Debug("InitiateReveal: SeqAllottedCollections: ", globalCommitDataStruct.SeqAllottedCollections) - log.Debug("InitiateReveal: Leaves: ", globalCommitDataStruct.Leaves) - - commitDataToSend := types.CommitData{ - Leaves: globalCommitDataStruct.Leaves, - AssignedCollections: globalCommitDataStruct.AssignedCollections, - SeqAllottedCollections: globalCommitDataStruct.SeqAllottedCollections, - } - log.Debugf("InitiateReveal: Calling Reveal() with arguments epoch = %d, commitDataToSend = %+v, signature = %v", epoch, commitDataToSend, signature) - revealTxn, err := cmdUtils.Reveal(client, config, account, epoch, latestHeader, commitDataToSend, signature) - if err != nil { - return errors.New("Reveal error: " + err.Error()) - } - if revealTxn != core.NilHash { - waitForBlockCompletionErr := razorUtils.WaitForBlockCompletion(client, revealTxn.Hex()) - if waitForBlockCompletionErr != nil { - log.Error("Error in WaitForBlockCompletionErr for reveal: ", waitForBlockCompletionErr) - return err - } - } - } else { - log.Error("The commit data is outdated, does not match with the latest epoch") - return errors.New("outdated commit data") + commitDataToSend := types.CommitData{ + Leaves: commitData.Leaves, + AssignedCollections: commitData.AssignedCollections, + SeqAllottedCollections: commitData.SeqAllottedCollections, + } + log.Debugf("InitiateReveal: Calling Reveal() with arguments epoch = %d, commitDataToSend = %+v, signature = %v", epoch, commitDataToSend, signature) + revealTxn, err := cmdUtils.Reveal(rpcParameters, config, account, epoch, latestHeader, stateBuffer, commitDataToSend, signature) + if err != nil { + return errors.New("Reveal error: " + err.Error()) } + log.Info("InitiateReveal: Reveal Transaction Hash: ", revealTxn) return nil } //This function initiates the propose -func (*UtilsStruct) InitiatePropose(client *ethclient.Client, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *Types.Header, rogueData types.Rogue) error { +func (*UtilsStruct) InitiatePropose(rpcParameters rpc.RPCParameters, config types.Configurations, account types.Account, epoch uint32, staker bindings.StructsStaker, latestHeader *Types.Header, stateBuffer uint64, rogueData types.Rogue) error { stakedAmount := staker.Stake log.Debug("InitiatePropose: Staked Amount: ", stakedAmount) - minStakeAmount, err := razorUtils.GetMinStakeAmount(client) + minStakeAmount, err := razorUtils.GetMinStakeAmount(rpcParameters) if err != nil { log.Error("Error in getting minimum stake amount: ", err) return err @@ -574,7 +535,7 @@ func (*UtilsStruct) InitiatePropose(client *ethclient.Client, config types.Confi log.Error("Stake is below minimum required. Kindly add stake to continue voting.") return nil } - lastProposal, err := razorUtils.GetEpochLastProposed(client, staker.Id) + lastProposal, err := razorUtils.GetEpochLastProposed(rpcParameters, staker.Id) if err != nil { return errors.New("Error in fetching last proposal: " + err.Error()) } @@ -583,7 +544,7 @@ func (*UtilsStruct) InitiatePropose(client *ethclient.Client, config types.Confi log.Debugf("Since last propose was at epoch: %d, won't propose again in epoch: %d", epoch, lastProposal) return nil } - lastReveal, err := razorUtils.GetEpochLastRevealed(client, staker.Id) + lastReveal, err := razorUtils.GetEpochLastRevealed(rpcParameters, staker.Id) if err != nil { return errors.New("Error in fetching last reveal: " + err.Error()) } @@ -594,7 +555,7 @@ func (*UtilsStruct) InitiatePropose(client *ethclient.Client, config types.Confi } log.Debugf("InitiatePropose: Calling Propose() with arguments staker = %+v, epoch = %d, blockNumber = %s, rogueData = %+v", staker, epoch, latestHeader.Number, rogueData) - err = cmdUtils.Propose(client, config, account, staker, epoch, latestHeader, rogueData) + err = cmdUtils.Propose(rpcParameters, config, account, staker, epoch, latestHeader, stateBuffer, rogueData) if err != nil { return errors.New("Propose error: " + err.Error()) } @@ -635,11 +596,12 @@ func (*UtilsStruct) CalculateSecret(account types.Account, epoch uint32, keystor return signedData, secret, nil } -func updateGlobalCommitDataStruct(commitData types.CommitData, epoch uint32) types.CommitFileData { +func updateGlobalCommitDataStruct(commitData types.CommitData, commitment [32]byte, epoch uint32) types.CommitFileData { globalCommitDataStruct.Leaves = commitData.Leaves globalCommitDataStruct.AssignedCollections = commitData.AssignedCollections globalCommitDataStruct.SeqAllottedCollections = commitData.SeqAllottedCollections globalCommitDataStruct.Epoch = epoch + globalCommitDataStruct.Commitment = commitment return globalCommitDataStruct } diff --git a/cmd/vote_test.go b/cmd/vote_test.go index 4809a8ad6..2476dd403 100644 --- a/cmd/vote_test.go +++ b/cmd/vote_test.go @@ -4,20 +4,20 @@ import ( "context" "encoding/hex" "errors" + Types "github.com/ethereum/go-ethereum/core/types" "math/big" "os" "path" "path/filepath" "razor/accounts" + "razor/block" "razor/cache" "razor/core/types" "razor/pkg/bindings" + "razor/rpc" "razor/utils" "reflect" "testing" - "time" - - Types "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/ethclient" @@ -151,14 +151,16 @@ func TestExecuteVote(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + setupTestEndpointsEnvironment() + utilsMock.On("IsFlagPassed", mock.Anything).Return(true) fileUtilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"), mock.Anything) cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr) utilsMock.On("GetStateBuffer", mock.Anything).Return(uint64(5), nil) @@ -169,7 +171,7 @@ func TestExecuteVote(t *testing.T) { flagSetMock.On("GetStringSliceBackupNode", mock.Anything).Return([]string{}, nil) utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client) flagSetMock.On("GetBoolRogue", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.rogueStatus, tt.args.rogueErr) - utilsMock.On("GetStakerId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.stakerId, tt.args.stakerIdErr) + utilsMock.On("GetStakerId", mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) flagSetMock.On("GetStringSliceRogueMode", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.rogueMode, tt.args.rogueModeErr) cmdUtilsMock.On("InitJobAndCollectionCache", mock.Anything).Return(&cache.JobsCache{}, &cache.CollectionsCache{}, big.NewInt(100), nil) cmdUtilsMock.On("HandleExit").Return() @@ -336,9 +338,9 @@ func TestCalculateSecret(t *testing.T) { func TestInitiateCommit(t *testing.T) { var ( - client *ethclient.Client config types.Configurations latestHeader *Types.Header + stateBuffer uint64 account types.Account stakerId uint32 rogueData types.Rogue @@ -352,28 +354,27 @@ func TestInitiateCommit(t *testing.T) { } type args struct { - staker bindings.StructsStaker - stakerErr error - minStakeAmount *big.Int - minStakeAmountErr error - epoch uint32 - lastCommit uint32 - lastCommitErr error - secret []byte - secretErr error - signature []byte - salt [32]byte - saltErr error - path string - pathErr error - commitData types.CommitData - commitDataErr error - commitTxn common.Hash - commitTxnErr error - waitForBlockCompletionErr error - fileName string - fileNameErr error - saveErr error + staker bindings.StructsStaker + stakerErr error + minStakeAmount *big.Int + minStakeAmountErr error + epoch uint32 + lastCommit uint32 + lastCommitErr error + secret []byte + secretErr error + signature []byte + salt [32]byte + saltErr error + path string + pathErr error + commitData types.CommitData + commitDataErr error + commitTxn common.Hash + commitTxnErr error + fileName string + fileNameErr error + saveErr error } tests := []struct { name string @@ -393,7 +394,7 @@ func TestInitiateCommit(t *testing.T) { commitData: types.CommitData{ AssignedCollections: nil, SeqAllottedCollections: nil, - Leaves: nil, + Leaves: []*big.Int{big.NewInt(100)}, }, commitTxn: common.BigToHash(big.NewInt(1)), fileName: "", @@ -519,28 +520,29 @@ func TestInitiateCommit(t *testing.T) { wantErr: true, }, { - name: "Test 12: When there is an error in sending commit transaction", + name: "Test 12: When there is an error in getting path", args: args{ epoch: 5, lastCommit: 2, - secret: []byte{1}, - salt: [32]byte{}, - commitData: types.CommitData{ - AssignedCollections: nil, - SeqAllottedCollections: nil, - Leaves: nil, - }, - commitTxn: common.BigToHash(big.NewInt(1)), - waitForBlockCompletionErr: errors.New("transaction mining unsuccessful"), + pathErr: errors.New("path error"), }, wantErr: true, }, { - name: "Test 13: When there is an error in getting path", + name: "Test 13: When there is an error in getting commitment as values is nil", args: args{ - epoch: 5, - lastCommit: 2, - pathErr: errors.New("path error"), + staker: bindings.StructsStaker{Id: 1, Stake: big.NewInt(10000)}, + minStakeAmount: big.NewInt(100), + epoch: 5, + lastCommit: 2, + signature: []byte{2}, + secret: []byte{1}, + salt: [32]byte{}, + commitData: types.CommitData{ + AssignedCollections: nil, + SeqAllottedCollections: nil, + Leaves: []*big.Int{}, + }, }, wantErr: true, }, @@ -549,21 +551,23 @@ func TestInitiateCommit(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetStaker", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.staker, tt.args.stakerErr) - utilsMock.On("GetMinStakeAmount", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.minStakeAmount, tt.args.minStakeAmountErr) - utilsMock.On("GetEpochLastCommitted", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.lastCommit, tt.args.lastCommitErr) - cmdUtilsMock.On("CalculateSecret", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.signature, tt.args.secret, tt.args.secretErr) - cmdUtilsMock.On("GetSalt", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.salt, tt.args.saltErr) + utils.MerkleInterface = &utils.MerkleTreeStruct{} + merkleUtils = utils.MerkleInterface + + utilsMock.On("GetStaker", mock.Anything, mock.Anything).Return(tt.args.staker, tt.args.stakerErr) + utilsMock.On("GetMinStakeAmount", mock.Anything).Return(tt.args.minStakeAmount, tt.args.minStakeAmountErr) + utilsMock.On("GetEpochLastCommitted", mock.Anything, mock.Anything).Return(tt.args.lastCommit, tt.args.lastCommitErr) + cmdUtilsMock.On("CalculateSecret", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.signature, tt.args.secret, tt.args.secretErr) + cmdUtilsMock.On("GetSalt", mock.Anything, mock.Anything).Return(tt.args.salt, tt.args.saltErr) cmdUtilsMock.On("HandleCommitState", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.commitData, tt.args.commitDataErr) pathMock.On("GetDefaultPath").Return(tt.args.path, tt.args.pathErr) - cmdUtilsMock.On("Commit", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.commitTxn, tt.args.commitTxnErr) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.waitForBlockCompletionErr) + cmdUtilsMock.On("Commit", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.commitTxn, tt.args.commitTxnErr) pathMock.On("GetCommitDataFileName", mock.AnythingOfType("string")).Return(tt.args.fileName, tt.args.fileNameErr) - fileUtilsMock.On("SaveDataToCommitJsonFile", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.saveErr) + fileUtilsMock.On("SaveDataToCommitJsonFile", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.saveErr) clientUtilsMock.On("GetLatestBlockWithRetry", mock.Anything).Return(&Types.Header{Number: big.NewInt(100)}, nil) - clientUtilsMock.On("FilterLogsWithRetry", mock.Anything, mock.Anything).Return([]Types.Log{}, nil) + clientUtilsMock.On("FilterLogsWithRetry", mock.Anything, mock.Anything, mock.Anything).Return([]Types.Log{}, nil) ut := &UtilsStruct{} - if err := ut.InitiateCommit(client, config, account, tt.args.epoch, stakerId, latestHeader, commitParams, rogueData); (err != nil) != tt.wantErr { + if err := ut.InitiateCommit(rpcParameters, config, account, tt.args.epoch, stakerId, latestHeader, commitParams, stateBuffer, rogueData); (err != nil) != tt.wantErr { t.Errorf("InitiateCommit() error = %v, wantErr %v", err, tt.wantErr) } }) @@ -572,14 +576,20 @@ func TestInitiateCommit(t *testing.T) { func TestInitiateReveal(t *testing.T) { var ( - client *ethclient.Client config types.Configurations account types.Account latestHeader *Types.Header + stateBuffer uint64 ) + decodedCommitment, _ := hex.DecodeString("f3955999458f88a8440026a24e53c0761b67475e742556bf55bbe3bbdf5028ed") + var decodedCommitment32 [32]byte + copy(decodedCommitment32[:], decodedCommitment) + randomNum := big.NewInt(1111) globalCommitDataStruct.Epoch = 5 + globalCommitDataStruct.Leaves = []*big.Int{big.NewInt(100), big.NewInt(101)} + globalCommitDataStruct.Commitment = decodedCommitment32 type args struct { staker bindings.StructsStaker @@ -610,15 +620,13 @@ func TestInitiateReveal(t *testing.T) { { name: "Test 1: When InitiateReveal executes successfully", args: args{ - staker: bindings.StructsStaker{Id: 1, Stake: big.NewInt(10000)}, - minStakeAmount: big.NewInt(100), - epoch: 5, - lastReveal: 2, - fileName: "", - committedDataFromFile: types.CommitFileData{Epoch: 5}, - signature: []byte{1}, - secret: []byte{}, - revealTxn: common.BigToHash(big.NewInt(1)), + staker: bindings.StructsStaker{Id: 1, Stake: big.NewInt(10000)}, + minStakeAmount: big.NewInt(100), + epoch: 5, + lastReveal: 2, + signature: []byte{1}, + secret: []byte{}, + revealTxn: common.BigToHash(big.NewInt(1)), }, wantErr: false, }, @@ -733,8 +741,9 @@ func TestInitiateReveal(t *testing.T) { lastReveal: 2, fileName: "", committedDataFromFile: types.CommitFileData{ - Epoch: 5, - Leaves: []*big.Int{big.NewInt(1), big.NewInt(2)}, + Epoch: 5, + Leaves: []*big.Int{big.NewInt(1), big.NewInt(2)}, + Commitment: decodedCommitment32, }, secret: []byte{}, revealTxn: common.BigToHash(big.NewInt(1)), @@ -771,20 +780,20 @@ func TestInitiateReveal(t *testing.T) { utils.MerkleInterface = &utils.MerkleTreeStruct{} merkleUtils = utils.MerkleInterface - utilsMock.On("GetMinStakeAmount", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.minStakeAmount, tt.args.minStakeAmountErr) - utilsMock.On("GetEpochLastRevealed", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.lastReveal, tt.args.lastRevealErr) - cmdUtilsMock.On("CheckForLastCommitted", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.AnythingOfType("uint32")).Return(tt.args.revealStateErr) + utilsMock.On("GetMinStakeAmount", mock.Anything).Return(tt.args.minStakeAmount, tt.args.minStakeAmountErr) + utilsMock.On("GetEpochLastRevealed", mock.Anything, mock.Anything).Return(tt.args.lastReveal, tt.args.lastRevealErr) + cmdUtilsMock.On("CheckForLastCommitted", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.revealStateErr) pathMock.On("GetCommitDataFileName", mock.AnythingOfType("string")).Return(tt.args.fileName, tt.args.fileNameErr) fileUtilsMock.On("ReadFromCommitJsonFile", mock.Anything).Return(tt.args.committedDataFromFile, tt.args.committedDataFromFileErr) utilsMock.On("GetRogueRandomValue", mock.AnythingOfType("int")).Return(randomNum) pathMock.On("GetDefaultPath").Return(tt.args.path, tt.args.pathErr) - cmdUtilsMock.On("CalculateSecret", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.signature, tt.args.secret, tt.args.secretErr) + cmdUtilsMock.On("CalculateSecret", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.signature, tt.args.secret, tt.args.secretErr) cmdUtilsMock.On("GetSalt", mock.Anything, mock.Anything).Return([32]byte{}, nil) - utilsMock.On("GetCommitment", mock.Anything, mock.Anything).Return(types.Commitment{}, nil) + utilsMock.On("GetCommitment", mock.Anything, mock.Anything).Return(types.Commitment{CommitmentHash: decodedCommitment32}, nil) cmdUtilsMock.On("Reveal", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.revealTxn, tt.args.revealTxnErr) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) ut := &UtilsStruct{} - if err := ut.InitiateReveal(client, config, account, tt.args.epoch, tt.args.staker, latestHeader, tt.args.rogueData); (err != nil) != tt.wantErr { + if err := ut.InitiateReveal(rpcParameters, config, account, tt.args.epoch, tt.args.staker, latestHeader, stateBuffer, tt.args.rogueData); (err != nil) != tt.wantErr { t.Errorf("InitiateReveal() error = %v, wantErr %v", err, tt.wantErr) } }) @@ -793,10 +802,10 @@ func TestInitiateReveal(t *testing.T) { func TestInitiatePropose(t *testing.T) { var ( - client *ethclient.Client - config types.Configurations - account types.Account - rogueData types.Rogue + config types.Configurations + account types.Account + rogueData types.Rogue + stateBuffer uint64 ) type args struct { staker bindings.StructsStaker @@ -897,13 +906,13 @@ func TestInitiatePropose(t *testing.T) { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() - utilsMock.On("GetMinStakeAmount", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.minStakeAmount, tt.args.minStakeAmountErr) - utilsMock.On("GetEpochLastProposed", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.lastProposal, tt.args.lastProposalErr) - utilsMock.On("GetEpochLastRevealed", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.lastReveal, tt.args.lastRevealErr) + utilsMock.On("GetMinStakeAmount", mock.Anything).Return(tt.args.minStakeAmount, tt.args.minStakeAmountErr) + utilsMock.On("GetEpochLastProposed", mock.Anything, mock.Anything).Return(tt.args.lastProposal, tt.args.lastProposalErr) + utilsMock.On("GetEpochLastRevealed", mock.Anything, mock.Anything).Return(tt.args.lastReveal, tt.args.lastRevealErr) cmdUtilsMock.On("Propose", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.proposeTxnErr) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(nil) + utilsMock.On("WaitForBlockCompletion", mock.Anything, mock.Anything).Return(nil) ut := &UtilsStruct{} - if err := ut.InitiatePropose(client, config, account, tt.args.epoch, tt.args.staker, latestHeader, rogueData); (err != nil) != tt.wantErr { + if err := ut.InitiatePropose(rpcParameters, config, account, tt.args.epoch, tt.args.staker, latestHeader, stateBuffer, rogueData); (err != nil) != tt.wantErr { t.Errorf("InitiatePropose() error = %v, wantErr %v", err, tt.wantErr) } }) @@ -912,7 +921,6 @@ func TestInitiatePropose(t *testing.T) { func TestHandleBlock(t *testing.T) { var ( - client *ethclient.Client account types.Account stakerId uint32 commitParams *types.CommitParams @@ -924,31 +932,35 @@ func TestHandleBlock(t *testing.T) { Number: big.NewInt(1001), } type args struct { - config types.Configurations - state int64 - stateErr error - epoch uint32 - epochErr error - stateName string - staker bindings.StructsStaker - stakerErr error - ethBalance *big.Int - ethBalanceErr error - actualStake *big.Float - actualStakeErr error - actualBalance *big.Float - sRZRBalance *big.Int - sRZRBalanceErr error - sRZRInEth *big.Float - initiateCommitErr error - initiateRevealErr error - initiateProposeErr error - handleDisputeErr error - claimBlockRewardTxn common.Hash - claimBlockRewardErr error - lastVerification uint32 - isFlagPassed bool - handleClaimBountyErr error + config types.Configurations + stateBufferErr error + stateRemainingTimeErr error + state int64 + stateErr error + epoch uint32 + epochErr error + stateName string + staker bindings.StructsStaker + stakerErr error + ethBalance *big.Int + ethBalanceErr error + actualStake *big.Float + actualStakeErr error + actualBalance *big.Float + sRZRBalance *big.Int + sRZRBalanceErr error + sRZRInEth *big.Float + initiateCommitErr error + initiateRevealErr error + initiateProposeErr error + handleDisputeErr error + claimBlockRewardTxn common.Hash + claimBlockRewardErr error + lastVerification uint32 + isFlagPassed bool + handleClaimBountyErr error + confirmedBlock types.ConfirmedBlock + confirmedBlockErr error } tests := []struct { name string @@ -1162,33 +1174,38 @@ func TestHandleBlock(t *testing.T) { { name: "Test 19: When claimBlockReward executes successfully in confirm state", args: args{ - state: 4, - epoch: 1, - stateName: "confirm", - lastVerification: 1, - staker: bindings.StructsStaker{Id: 1, Stake: big.NewInt(10000)}, - ethBalance: big.NewInt(1000), - actualStake: big.NewFloat(10000), - actualBalance: big.NewFloat(1000), - sRZRBalance: big.NewInt(10000), - sRZRInEth: big.NewFloat(100), + state: 4, + epoch: 1, + stateName: "confirm", + lastVerification: 1, + staker: bindings.StructsStaker{Id: 1, Stake: big.NewInt(10000)}, + ethBalance: big.NewInt(1000), + actualStake: big.NewFloat(10000), + actualBalance: big.NewFloat(1000), + sRZRBalance: big.NewInt(10000), + sRZRInEth: big.NewFloat(100), + confirmedBlock: types.ConfirmedBlock{ + ProposerId: 0, + }, claimBlockRewardTxn: common.BigToHash(big.NewInt(1)), }, }, { - name: "Test 20: When there is an error in claimBlockReward", + name: "Test 20: When in confirm state and the block is already confirmed", args: args{ - state: 4, - epoch: 2, - stateName: "confirm", - lastVerification: 1, - staker: bindings.StructsStaker{Id: 2, Stake: big.NewInt(10000)}, - ethBalance: big.NewInt(1000), - actualStake: big.NewFloat(10000), - actualBalance: big.NewFloat(1000), - sRZRBalance: big.NewInt(10000), - sRZRInEth: big.NewFloat(100), - claimBlockRewardErr: errors.New("error in claimBlockReward"), + state: 4, + epoch: 2, + stateName: "confirm", + lastVerification: 1, + staker: bindings.StructsStaker{Id: 2, Stake: big.NewInt(10000)}, + ethBalance: big.NewInt(1000), + actualStake: big.NewFloat(10000), + actualBalance: big.NewFloat(1000), + sRZRBalance: big.NewInt(10000), + sRZRInEth: big.NewFloat(100), + confirmedBlock: types.ConfirmedBlock{ + ProposerId: 1, + }, }, }, { @@ -1222,30 +1239,54 @@ func TestHandleBlock(t *testing.T) { config: types.Configurations{WaitTime: 6}, }, }, + { + name: "Test 23: When there is an error in getting stateBuffer", + args: args{ + stateBufferErr: errors.New("state buffer error"), + }, + }, + { + name: "Test 24: When in confirm state and there is an error in getting confirmed block for the epoch", + args: args{ + state: 4, + epoch: 2, + stateName: "confirm", + lastVerification: 1, + staker: bindings.StructsStaker{Id: 2, Stake: big.NewInt(10000)}, + ethBalance: big.NewInt(1000), + actualStake: big.NewFloat(10000), + actualBalance: big.NewFloat(1000), + sRZRBalance: big.NewInt(10000), + sRZRInEth: big.NewFloat(100), + confirmedBlockErr: errors.New("blocks error"), + }, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { SetUpMockInterfaces() + utilsMock.On("GetStateBuffer", mock.Anything).Return(uint64(5), tt.args.stateBufferErr) + utilsMock.On("GetRemainingTimeOfCurrentState", mock.Anything, mock.Anything, mock.Anything).Return(int64(10), tt.args.stateRemainingTimeErr) utilsMock.On("GetBufferedState", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.state, tt.args.stateErr) - utilsMock.On("GetEpoch", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epoch, tt.args.epochErr) - utilsMock.On("GetStaker", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.staker, tt.args.stakerErr) - clientUtilsMock.On("BalanceAtWithRetry", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.ethBalance, tt.args.ethBalanceErr) + utilsMock.On("GetEpoch", mock.Anything).Return(tt.args.epoch, tt.args.epochErr) + utilsMock.On("GetStaker", mock.Anything, mock.Anything).Return(tt.args.staker, tt.args.stakerErr) + clientUtilsMock.On("BalanceAtWithRetry", mock.Anything, mock.Anything).Return(tt.args.ethBalance, tt.args.ethBalanceErr) utilsMock.On("GetStakerSRZRBalance", mock.Anything, mock.Anything).Return(tt.args.sRZRBalance, tt.args.sRZRBalanceErr) osMock.On("Exit", mock.AnythingOfType("int")).Return() - cmdUtilsMock.On("InitiateCommit", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.initiateCommitErr) - cmdUtilsMock.On("InitiateReveal", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.initiateRevealErr) - cmdUtilsMock.On("InitiatePropose", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.initiateProposeErr) + cmdUtilsMock.On("InitiateCommit", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.initiateCommitErr) + cmdUtilsMock.On("InitiateReveal", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.initiateRevealErr) + cmdUtilsMock.On("InitiatePropose", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.initiateProposeErr) cmdUtilsMock.On("HandleDispute", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.handleDisputeErr) utilsMock.On("IsFlagPassed", mock.AnythingOfType("string")).Return(tt.args.isFlagPassed) cmdUtilsMock.On("HandleClaimBounty", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.handleClaimBountyErr) - cmdUtilsMock.On("ClaimBlockReward", mock.Anything).Return(tt.args.claimBlockRewardTxn, tt.args.claimBlockRewardErr) - utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(nil) + utilsMock.On("GetConfirmedBlocks", mock.Anything, mock.Anything).Return(tt.args.confirmedBlock, tt.args.confirmedBlockErr) + cmdUtilsMock.On("ClaimBlockReward", mock.Anything, mock.Anything).Return(tt.args.claimBlockRewardTxn, tt.args.claimBlockRewardErr) timeMock.On("Sleep", mock.Anything).Return() utilsMock.On("WaitTillNextNSecs", mock.AnythingOfType("int32")).Return() lastVerification = tt.args.lastVerification ut := &UtilsStruct{} - ut.HandleBlock(client, account, stakerId, latestHeader, tt.args.config, commitParams, rogueData, backupNodeActionsToIgnore) + ut.HandleBlock(rpcParameters, account, stakerId, latestHeader, tt.args.config, commitParams, rogueData, backupNodeActionsToIgnore) }) } } @@ -1253,7 +1294,6 @@ func TestHandleBlock(t *testing.T) { func TestVote(t *testing.T) { var ( config types.Configurations - client *ethclient.Client rogueData types.Rogue account types.Account stakerId uint32 @@ -1288,16 +1328,18 @@ func TestVote(t *testing.T) { clientUtilsMock.On("GetLatestBlockWithRetry", mock.Anything).Return(tt.args.header, nil) cmdUtilsMock.On("HandleBlock", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) + localRpcParameters := rpc.RPCParameters{ + Ctx: ctx, + RPCManager: &rpcManager, + } + ut := &UtilsStruct{} errChan := make(chan error) // Run Vote function in a goroutine go func() { - errChan <- ut.Vote(ctx, config, client, account, stakerId, commitParams, rogueData, backupNodeActionsToIgnore) + errChan <- ut.Vote(localRpcParameters, &block.BlockMonitor{}, config, account, stakerId, commitParams, rogueData, backupNodeActionsToIgnore) }() - // Wait for some time to allow Vote function to execute - time.Sleep(time.Second * 2) - // Cancel the context to simulate its done cancel() diff --git a/config.sh b/config.sh index 89ca8532e..96af7366b 100644 --- a/config.sh +++ b/config.sh @@ -11,8 +11,6 @@ then PROVIDER="http://127.0.0.1:8545" fi -read -rp "Alternate Provider: " ALTERNATE_PROVIDER - read -rp "Gas Multiplier: (1.0) " GAS_MULTIPLIER if [ -z "$GAS_MULTIPLIER" ]; then @@ -55,9 +53,4 @@ if [ -z "$MAX_AGE" ]; then MAX_AGE=60 fi -ALT_PROVIDER_OPTION="" -if [ -n "$ALTERNATE_PROVIDER" ]; then - ALT_PROVIDER_OPTION="--alternateProvider $ALTERNATE_PROVIDER" -fi - -$RAZOR setConfig -p $PROVIDER $ALT_PROVIDER_OPTION -b $BUFFER -g $GAS_MULTIPLIER -w $WAIT_TIME --gasprice $GAS_PRICE --gasLimit $GAS_LIMIT --rpcTimeout 5 --httpTimeout 5 --logFileMaxSize $MAX_SIZE --logFileMaxBackups $MAX_BACKUPS --logFileMaxAge $MAX_AGE \ No newline at end of file +$RAZOR setConfig -p $PROVIDER -b $BUFFER -g $GAS_MULTIPLIER -w $WAIT_TIME --gasprice $GAS_PRICE --gasLimit $GAS_LIMIT --rpcTimeout 5 --httpTimeout 5 --logFileMaxSize $MAX_SIZE --logFileMaxBackups $MAX_BACKUPS --logFileMaxAge $MAX_AGE \ No newline at end of file diff --git a/core/constants.go b/core/constants.go index cb016ca76..e64548d25 100644 --- a/core/constants.go +++ b/core/constants.go @@ -25,8 +25,9 @@ const ( var NilHash = common.Hash{0x00} const ( - BlockCompletionAttempts = 3 - BlockCompletionAttemptRetryDelay = 1 + BlockCompletionAttempts = 4 + BlockCompletionAttemptRetryDelay = 2 + BlockCompletionTimeout = 15 ) //Following are the default config values for all the config parameters @@ -68,8 +69,17 @@ const ( DefaultPathName = ".razor" ) -//BlockNumberInterval is the interval in seconds after which blockNumber needs to be calculated again -const BlockNumberInterval = 5 +const ( + //BlockNumberInterval is the interval in seconds after which blockNumber needs to be calculated again by blockMonitor + BlockNumberInterval = 5 + + // StaleBlockNumberCheckInterval specifies the duration in seconds after which the BlockMonitor + // switches to an alternate endpoint if the block number remains unchanged, indicating a potential stale endpoint. + StaleBlockNumberCheckInterval = 15 +) + +//EndpointsContextTimeout defines the maximum duration in seconds to wait for establishing a connection for an endpoint +const EndpointsContextTimeout = 5 //APIKeyRegex will be used as a regular expression to be matched in job Urls const APIKeyRegex = `\$\{(.+?)\}` @@ -80,9 +90,6 @@ const ( ProcessRequestRetryDelay int64 = 2 ) -//SwitchClientDuration is the time after which alternate client from secondary RPC will be switched back to client from primary RPC -const SwitchClientDuration = 5 * EpochLength - const ( // HexReturnType is the ReturnType for a job if that job returns a hex value HexReturnType = "hex" diff --git a/core/endpoints.go b/core/endpoints.go new file mode 100644 index 000000000..813f0f522 --- /dev/null +++ b/core/endpoints.go @@ -0,0 +1,20 @@ +package core + +var DefaultEndpoints = []string{ + "https://andromeda02.skale.prod.chorus1.net:10072", + "https://skale-figment-9.skale.figment.io:10008", + "https://skale-figment-2.skale.figment.io:10072", + "https://node03.skale.prod.chorus1.net:10072", + "https://skale.tuku.dev:10136", + "https://signia-node-8.skale.bdnodes.net:10072", + "https://skale.infstones.io:10136", + "https://skale-figment-8.skale.figment.io:10200", + "https://node05.skale.prod.chorus1.net:10136", + "https://block-node-5.skale.bdnodes.net:10008", + "https://skale-figment-11.skale.figment.io:10072", + "https://skale-jupiter-2.skale.figment.io:10072", + "https://signia-node-5.skale.bdnodes.net:10328", + "https://block-node-8.skale.bdnodes.net:10008", + "https://skale-mainnet-1a.stakin-nodes.com:10072", + "https://skale2.anonstake.com:10008", +} diff --git a/core/types/block.go b/core/types/block.go index 2fa61fd82..cc059af6e 100644 --- a/core/types/block.go +++ b/core/types/block.go @@ -16,3 +16,10 @@ type DisputesStruct struct { AccWeight *big.Int Median *big.Int } + +type ConfirmedBlock struct { + Valid bool + ProposerId uint32 + Iteration *big.Int + BiggestStake *big.Int +} diff --git a/core/types/configurations.go b/core/types/configurations.go index da42176f9..2fded1d0b 100644 --- a/core/types/configurations.go +++ b/core/types/configurations.go @@ -2,7 +2,6 @@ package types type Configurations struct { Provider string - AlternateProvider string GasMultiplier float32 BufferPercent int32 WaitTime int32 diff --git a/core/types/transaction.go b/core/types/transaction.go index 75819cacf..0d7ce718b 100644 --- a/core/types/transaction.go +++ b/core/types/transaction.go @@ -1,12 +1,10 @@ package types import ( - "github.com/ethereum/go-ethereum/ethclient" "math/big" ) type TransactionOptions struct { - Client *ethclient.Client EtherValue *big.Int Amount *big.Int ChainId *big.Int diff --git a/core/types/vote.go b/core/types/vote.go index f1fb7b743..0ec230387 100644 --- a/core/types/vote.go +++ b/core/types/vote.go @@ -58,6 +58,7 @@ type CommitFileData struct { AssignedCollections map[int]bool SeqAllottedCollections []*big.Int Leaves []*big.Int + Commitment [32]byte } type ProposeFileData struct { diff --git a/core/version.go b/core/version.go index 15a0e147e..2c9cced42 100644 --- a/core/version.go +++ b/core/version.go @@ -4,7 +4,7 @@ import "fmt" const ( VersionMajor = 2 // Major version component of the current release - VersionMinor = 0 // Minor version component of the current release + VersionMinor = 1 // Minor version component of the current release VersionPatch = 0 // Patch version component of the current release VersionMeta = "" // Version metadata to append to the version string ) diff --git a/go.mod b/go.mod index 1c2247781..c956795b5 100644 --- a/go.mod +++ b/go.mod @@ -1,86 +1,98 @@ module razor -go 1.21 +go 1.23 require ( github.com/PaesslerAG/jsonpath v0.1.1 github.com/avast/retry-go v3.0.0+incompatible - github.com/ethereum/go-ethereum v1.12.2 + github.com/ethereum/go-ethereum v1.14.11 github.com/gocolly/colly v1.2.0 github.com/magiconair/properties v1.8.7 github.com/manifoldco/promptui v0.9.0 github.com/miguelmota/go-solidity-sha3 v0.1.1 github.com/olekukonko/tablewriter v0.0.5 - github.com/prometheus/client_golang v1.16.0 + github.com/prometheus/client_golang v1.20.5 github.com/razor-network/goInfo v0.0.0-20200404012835-b5f882ee2288 github.com/sirupsen/logrus v1.9.3 - github.com/spf13/cobra v1.7.0 + github.com/spf13/cobra v1.8.1 github.com/spf13/pflag v1.0.5 - github.com/spf13/viper v1.16.0 - github.com/stretchr/testify v1.8.4 - github.com/tidwall/gjson v1.16.0 + github.com/spf13/viper v1.19.0 + github.com/stretchr/testify v1.9.0 + github.com/tidwall/gjson v1.18.0 gopkg.in/natefinch/lumberjack.v2 v2.2.1 ) require ( - github.com/PaesslerAG/gval v1.2.2 // indirect - github.com/PuerkitoBio/goquery v1.8.1 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/PaesslerAG/gval v1.2.3 // indirect + github.com/PuerkitoBio/goquery v1.10.0 // indirect github.com/andybalholm/cascadia v1.3.2 // indirect - github.com/antchfx/htmlquery v1.3.0 // indirect - github.com/antchfx/xmlquery v1.3.17 // indirect - github.com/antchfx/xpath v1.2.4 // indirect + github.com/antchfx/htmlquery v1.3.3 // indirect + github.com/antchfx/xmlquery v1.4.2 // indirect + github.com/antchfx/xpath v1.3.2 // indirect github.com/beorn7/perks v1.0.1 // indirect - github.com/btcsuite/btcd v0.20.1-beta // indirect - github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect - github.com/cespare/xxhash/v2 v2.2.0 // indirect + github.com/bits-and-blooms/bitset v1.14.3 // indirect + github.com/btcsuite/btcd/btcec/v2 v2.3.4 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/chzyer/readline v1.5.1 // indirect - github.com/davecgh/go-spew v1.1.1 // indirect - github.com/deckarep/golang-set/v2 v2.3.1 // indirect - github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect - github.com/fsnotify/fsnotify v1.6.0 // indirect + github.com/consensys/bavard v0.1.22 // indirect + github.com/consensys/gnark-crypto v0.14.0 // indirect + github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a // indirect + github.com/crate-crypto/go-kzg-4844 v1.1.0 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/deckarep/golang-set/v2 v2.6.0 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 // indirect + github.com/ethereum/c-kzg-4844 v1.0.3 // indirect + github.com/ethereum/go-verkle v0.2.1 // indirect + github.com/fsnotify/fsnotify v1.7.0 // indirect github.com/go-ole/go-ole v1.3.0 // indirect - github.com/go-stack/stack v1.8.1 // indirect github.com/gobwas/glob v0.2.3 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect - github.com/golang/protobuf v1.5.3 // indirect - github.com/google/uuid v1.3.1 // indirect - github.com/gorilla/websocket v1.5.0 // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/gorilla/websocket v1.5.3 // indirect github.com/hashicorp/hcl v1.0.0 // indirect - github.com/holiman/uint256 v1.2.3 // indirect + github.com/holiman/uint256 v1.3.1 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/kennygrant/sanitize v1.2.4 // indirect - github.com/mattn/go-isatty v0.0.19 // indirect - github.com/mattn/go-runewidth v0.0.15 // indirect - github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect + github.com/klauspost/compress v1.17.11 // indirect + github.com/mattn/go-runewidth v0.0.16 // indirect github.com/mitchellh/mapstructure v1.5.0 // indirect - github.com/pelletier/go-toml/v2 v2.1.0 // indirect - github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/prometheus/client_model v0.4.0 // indirect - github.com/prometheus/common v0.44.0 // indirect - github.com/prometheus/procfs v0.11.1 // indirect - github.com/rivo/uniseg v0.4.4 // indirect + github.com/mmcloughlin/addchain v0.4.0 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/pelletier/go-toml/v2 v2.2.3 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/prometheus/client_model v0.6.1 // indirect + github.com/prometheus/common v0.60.1 // indirect + github.com/prometheus/procfs v0.15.1 // indirect + github.com/rivo/uniseg v0.4.7 // indirect + github.com/sagikazarmark/locafero v0.6.0 // indirect + github.com/sagikazarmark/slog-shim v0.1.0 // indirect github.com/saintfish/chardet v0.0.0-20230101081208-5e3ef4b5456d // indirect github.com/shirou/gopsutil v3.21.11+incompatible // indirect - github.com/shopspring/decimal v1.3.1 // indirect - github.com/spf13/afero v1.9.5 // indirect - github.com/spf13/cast v1.5.1 // indirect - github.com/spf13/jwalterweatherman v1.1.0 // indirect - github.com/stretchr/objx v0.5.1 // indirect + github.com/shopspring/decimal v1.4.0 // indirect + github.com/sourcegraph/conc v0.3.0 // indirect + github.com/spf13/afero v1.11.0 // indirect + github.com/spf13/cast v1.7.0 // indirect + github.com/stretchr/objx v0.5.2 // indirect github.com/subosito/gotenv v1.6.0 // indirect + github.com/supranational/blst v0.3.13 // indirect github.com/temoto/robotstxt v1.1.2 // indirect github.com/tidwall/match v1.1.1 // indirect github.com/tidwall/pretty v1.2.1 // indirect - github.com/tklauser/go-sysconf v0.3.12 // indirect - github.com/tklauser/numcpus v0.6.1 // indirect - github.com/yusufpapurcu/wmi v1.2.3 // indirect - golang.org/x/crypto v0.13.0 // indirect - golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect - golang.org/x/net v0.15.0 // indirect - golang.org/x/sys v0.12.0 // indirect - golang.org/x/text v0.13.0 // indirect + github.com/tklauser/go-sysconf v0.3.14 // indirect + github.com/tklauser/numcpus v0.9.0 // indirect + github.com/yusufpapurcu/wmi v1.2.4 // indirect + go.uber.org/multierr v1.11.0 // indirect + golang.org/x/crypto v0.28.0 // indirect + golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c // indirect + golang.org/x/net v0.30.0 // indirect + golang.org/x/sync v0.8.0 // indirect + golang.org/x/sys v0.26.0 // indirect + golang.org/x/text v0.19.0 // indirect google.golang.org/appengine v1.6.8 // indirect - google.golang.org/protobuf v1.31.0 // indirect + google.golang.org/protobuf v1.35.1 // indirect gopkg.in/ini.v1 v1.67.0 // indirect - gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect gopkg.in/yaml.v3 v3.0.1 // indirect + rsc.io/tmplfunc v0.0.3 // indirect ) diff --git a/go.sum b/go.sum index 5799df634..cec276b30 100644 --- a/go.sum +++ b/go.sum @@ -1,78 +1,36 @@ -cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= -cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= -cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= -cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= -cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= -cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= -cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= -cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= -cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= -cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= -cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= -cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= -cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= -cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= -cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= -cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= -cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= -cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= -cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= -cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= -cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= -cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= -cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= -cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= -cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= -cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= -cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= -cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= -cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= -cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= -cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= -cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= -cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= -cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= -cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= -cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= -cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= -dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= -github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= -github.com/BurntSushi/toml v1.2.1 h1:9F2/+DoOYIOksmaJFPw1tGFy1eDnIJXg+UHjuD8lTak= -github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= -github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= -github.com/DataDog/zstd v1.5.2 h1:vUG4lAyuPCXO0TLbXvPv7EB7cNK1QV/luu55UHLrrn8= -github.com/DataDog/zstd v1.5.2/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= +github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ= +github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= github.com/PaesslerAG/gval v1.0.0/go.mod h1:y/nm5yEyTeX6av0OfKJNp9rBNj2XrGhAf5+v24IBN1I= -github.com/PaesslerAG/gval v1.2.2 h1:Y7iBzhgE09IGTt5QgGQ2IdaYYYOU134YGHBThD+wm9E= -github.com/PaesslerAG/gval v1.2.2/go.mod h1:XRFLwvmkTEdYziLdaCeCa5ImcGVrfQbeNUbVR+C6xac= +github.com/PaesslerAG/gval v1.2.3 h1:Z3B/zLyWvqxjUtkIOEkFauqLnQn8Q37F1Q+uAjLXgMw= +github.com/PaesslerAG/gval v1.2.3/go.mod h1:XRFLwvmkTEdYziLdaCeCa5ImcGVrfQbeNUbVR+C6xac= github.com/PaesslerAG/jsonpath v0.1.0/go.mod h1:4BzmtoM/PI8fPO4aQGIusjGxGir2BzcV0grWtFzq1Y8= github.com/PaesslerAG/jsonpath v0.1.1 h1:c1/AToHQMVsduPAa4Vh6xp2U0evy4t8SWp8imEsylIk= github.com/PaesslerAG/jsonpath v0.1.1/go.mod h1:lVboNxFGal/VwW6d9JzIy56bUsYAP6tH/x80vjnCseY= -github.com/PuerkitoBio/goquery v1.8.1 h1:uQxhNlArOIdbrH1tr0UXwdVFgDcZDrZVdcpygAcwmWM= -github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJsnnd3H7Ho5jQ= -github.com/VictoriaMetrics/fastcache v1.6.0 h1:C/3Oi3EiBCqufydp1neRZkqcwmEiuRT9c3fqvvgKm5o= -github.com/VictoriaMetrics/fastcache v1.6.0/go.mod h1:0qHz5QP0GMX4pfmMA/zt5RgfNuXJrTP0zS7DqpHGGTw= +github.com/PuerkitoBio/goquery v1.10.0 h1:6fiXdLuUvYs2OJSvNRqlNPoBm6YABE226xrbavY5Wv4= +github.com/PuerkitoBio/goquery v1.10.0/go.mod h1:TjZZl68Q3eGHNBA8CWaxAN7rOU1EbDz3CWuolcO5Yu4= +github.com/VictoriaMetrics/fastcache v1.12.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjCM7NQbSmF7WI= +github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkThDcMsQicp4xDukwJYI= github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= -github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA= github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU= -github.com/antchfx/htmlquery v1.3.0 h1:5I5yNFOVI+egyia5F2s/5Do2nFWxJz41Tr3DyfKD25E= -github.com/antchfx/htmlquery v1.3.0/go.mod h1:zKPDVTMhfOmcwxheXUsx4rKJy8KEY/PU6eXr/2SebQ8= -github.com/antchfx/xmlquery v1.3.17 h1:d0qWjPp/D+vtRw7ivCwT5ApH/3CkQU8JOeo3245PpTk= -github.com/antchfx/xmlquery v1.3.17/go.mod h1:Afkq4JIeXut75taLSuI31ISJ/zeq+3jG7TunF7noreA= -github.com/antchfx/xpath v1.2.3/go.mod h1:i54GszH55fYfBmoZXapTHN8T8tkcHfRgLyVwwqzXNcs= -github.com/antchfx/xpath v1.2.4 h1:dW1HB/JxKvGtJ9WyVGJ0sIoEcqftV3SqIstujI+B9XY= -github.com/antchfx/xpath v1.2.4/go.mod h1:i54GszH55fYfBmoZXapTHN8T8tkcHfRgLyVwwqzXNcs= +github.com/antchfx/htmlquery v1.3.3 h1:x6tVzrRhVNfECDaVxnZi1mEGrQg3mjE/rxbH2Pe6dNE= +github.com/antchfx/htmlquery v1.3.3/go.mod h1:WeU3N7/rL6mb6dCwtE30dURBnBieKDC/fR8t6X+cKjU= +github.com/antchfx/xmlquery v1.4.2 h1:MZKd9+wblwxfQ1zd1AdrTsqVaMjMCwow3IqkCSe00KA= +github.com/antchfx/xmlquery v1.4.2/go.mod h1:QXhvf5ldTuGqhd1SHNvvtlhhdQLks4dD0awIVhXIDTA= +github.com/antchfx/xpath v1.3.2 h1:LNjzlsSjinu3bQpw9hWMY9ocB80oLOWuQqFvO6xt51U= +github.com/antchfx/xpath v1.3.2/go.mod h1:i54GszH55fYfBmoZXapTHN8T8tkcHfRgLyVwwqzXNcs= github.com/avast/retry-go v3.0.0+incompatible h1:4SOWQ7Qs+oroOTQOYnAHqelpCO0biHSxpiH9JdtuBj0= github.com/avast/retry-go v3.0.0+incompatible/go.mod h1:XtSnn+n/sHqQIpZ10K1qAevBhOOCWBLXXy3hyiqqBrY= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= -github.com/bits-and-blooms/bitset v1.7.0 h1:YjAGVd3XmtK9ktAbX8Zg2g2PwLIMjGREZJHlV4j7NEo= -github.com/bits-and-blooms/bitset v1.7.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA= +github.com/bits-and-blooms/bitset v1.14.3 h1:Gd2c8lSNf9pKXom5JtD7AaKO8o7fGQ2LtFj1436qilA= +github.com/bits-and-blooms/bitset v1.14.3/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= github.com/btcsuite/btcd v0.20.1-beta h1:Ik4hyJqN8Jfyv3S4AGBOmyouMsYE3EdYODkMbQjwPGw= github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= -github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U= -github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= +github.com/btcsuite/btcd/btcec/v2 v2.3.4 h1:3EJjcN70HCu/mwqlUsGK8GcNVyLVxFDlWurTXGPFfiQ= +github.com/btcsuite/btcd/btcec/v2 v2.3.4/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg= @@ -80,11 +38,10 @@ github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVa github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= -github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= -github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= -github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM= github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ= @@ -94,65 +51,57 @@ github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObk github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04= github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8= -github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= -github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= -github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= -github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= -github.com/cockroachdb/errors v1.9.1 h1:yFVvsI0VxmRShfawbt/laCIDy/mtTqqnvoNgiy5bEV8= -github.com/cockroachdb/errors v1.9.1/go.mod h1:2sxOtL2WIc096WSZqZ5h8fa17rdDq9HZOZLBCor4mBk= +github.com/cockroachdb/errors v1.11.3 h1:5bA+k2Y6r+oz/6Z/RFlNeVCesGARKuC6YymtcDrbC/I= +github.com/cockroachdb/errors v1.11.3/go.mod h1:m4UIW4CDjx+R5cybPsNrRbreomiFqt8o1h1wUVazSd8= +github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce h1:giXvy4KSc/6g/esnpM7Geqxka4WSqI1SZc7sMJFd3y4= +github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M= github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= -github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811 h1:ytcWPaNPhNoGMWEhDvS3zToKcDpRsLuRolQJBVGdozk= -github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811/go.mod h1:Nb5lgvnQ2+oGlE/EyZy4+2/CxRh9KfvCXnag1vtpxVM= -github.com/cockroachdb/redact v1.1.3 h1:AKZds10rFSIj7qADf0g46UixK8NNLwWTNdCIGS5wfSQ= -github.com/cockroachdb/redact v1.1.3/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= -github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= -github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= -github.com/consensys/gnark-crypto v0.10.0 h1:zRh22SR7o4K35SoNqouS9J/TKHTyU2QWaj5ldehyXtA= -github.com/consensys/gnark-crypto v0.10.0/go.mod h1:Iq/P3HHl0ElSjsg2E1gsMwhAyxnxoKK5nVyZKd+/KhU= -github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w= -github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/crate-crypto/go-kzg-4844 v0.3.0 h1:UBlWE0CgyFqqzTI+IFyCzA7A3Zw4iip6uzRv5NIXG0A= -github.com/crate-crypto/go-kzg-4844 v0.3.0/go.mod h1:SBP7ikXEgDnUPONgm33HtuDZEDtWa3L4QtN1ocJSEQ4= +github.com/cockroachdb/pebble v1.1.2 h1:CUh2IPtR4swHlEj48Rhfzw6l/d0qA31fItcIszQVIsA= +github.com/cockroachdb/pebble v1.1.2/go.mod h1:4exszw1r40423ZsmkG/09AFEG83I0uDgfujJdbL6kYU= +github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= +github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= +github.com/consensys/bavard v0.1.22 h1:Uw2CGvbXSZWhqK59X0VG/zOjpTFuOMcPLStrp1ihI0A= +github.com/consensys/bavard v0.1.22/go.mod h1:k/zVjHHC4B+PQy1Pg7fgvG3ALicQw540Crag8qx+dZs= +github.com/consensys/gnark-crypto v0.14.0 h1:DDBdl4HaBtdQsq/wfMwJvZNE80sHidrK3Nfrefatm0E= +github.com/consensys/gnark-crypto v0.14.0/go.mod h1:CU4UijNPsHawiVGNxe9co07FkzCeWHHrb1li/n1XoU0= +github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4= +github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a h1:W8mUrRp6NOVl3J+MYp5kPMoUZPp7aOYHtaua31lwRHg= +github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a/go.mod h1:sTwzHBvIzm2RfVCGNEBZgRyjwK40bVoun3ZnGOCafNM= +github.com/crate-crypto/go-kzg-4844 v1.1.0 h1:EN/u9k2TF6OWSHrCCDBBU6GLNMq88OspHHlMnHfoyU4= +github.com/crate-crypto/go-kzg-4844 v1.1.0/go.mod h1:JolLjpSff1tCCJKaJx4psrlEdlXuJEC996PL3tTAFks= github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/deckarep/golang-set/v2 v2.3.1 h1:vjmkvJt/IV27WXPyYQpAh4bRyWJc5Y435D17XQ9QU5A= -github.com/deckarep/golang-set/v2 v2.3.1/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/deckarep/golang-set/v2 v2.6.0 h1:XfcQbWM1LlMB8BsJ8N9vW5ehnnPVIw0je80NsVHagjM= +github.com/deckarep/golang-set/v2 v2.6.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y= github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0= -github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= -github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= -github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= -github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/ethereum/c-kzg-4844 v0.3.1 h1:sR65+68+WdnMKxseNWxSJuAv2tsUrihTpVBTfM/U5Zg= -github.com/ethereum/c-kzg-4844 v0.3.1/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= -github.com/ethereum/go-ethereum v1.12.2 h1:eGHJ4ij7oyVqUQn48LBz3B7pvQ8sV0wGJiIE6gDq/6Y= -github.com/ethereum/go-ethereum v1.12.2/go.mod h1:1cRAEV+rp/xX0zraSCBnu9Py3HQ+geRMj3HdR+k0wfI= -github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c= -github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= -github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY= -github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0= +github.com/ethereum/c-kzg-4844 v1.0.3 h1:IEnbOHwjixW2cTvKRUlAAUOeleV7nNM/umJR+qy4WDs= +github.com/ethereum/c-kzg-4844 v1.0.3/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.14.11 h1:8nFDCUUE67rPc6AKxFj7JKaOa2W/W1Rse3oS6LvvxEY= +github.com/ethereum/go-ethereum v1.14.11/go.mod h1:+l/fr42Mma+xBnhefL/+z11/hcmJ2egl+ScIVPjhc7E= +github.com/ethereum/go-verkle v0.2.1 h1:FYWEByFT19jT/ym/dy++E+f1SSw899uXGNrhCkwjYJw= +github.com/ethereum/go-verkle v0.2.1/go.mod h1:M3b90YRnzqKyyzBEWJGqj8Qff4IDeXnzFw0P9bFw3uk= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= -github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= +github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= +github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= -github.com/getsentry/sentry-go v0.18.0 h1:MtBW5H9QgdcJabtZcuJG80BMOwaBpkRDZkxRkNC1sN0= -github.com/getsentry/sentry-go v0.18.0/go.mod h1:Kgon4Mby+FJ7ZWHFUAZgVaIa8sxHtnRJRLTXZr51aKQ= -github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= -github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= -github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps= +github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= -github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw= -github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4= github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y= github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8= github.com/gocolly/colly v1.2.0 h1:qRz9YAn8FIH0qzgNUw+HT9UN7wm1oF9OBAilwEWpyrI= @@ -161,132 +110,70 @@ github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= -github.com/golang-jwt/jwt/v4 v4.3.0 h1:kHL1vqdqWNfATmA0FNMdmZNMyZI1U6O31X4rlIPoBog= -github.com/golang-jwt/jwt/v4 v4.3.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg= -github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= -github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= +github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE= github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= -github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= -github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= -github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= -github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= -github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= -github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= -github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= -github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= -github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= -github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= -github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= -github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= -github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= -github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= -github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= -github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= -github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= -github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= -github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= -github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= -github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= -github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= -github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= -github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= -github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= -github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= -github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/google/uuid v1.3.1 h1:KjJaJ9iWZ3jOFZIf1Lqf4laDRCasjl0BCmnEGxkdLb4= -github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= -github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= -github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= -github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= -github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= +github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= -github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= -github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7 h1:3JQNjnMRil1yD0IfZKHF9GxxWKDJGj8I0IqOUol//sw= -github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= +github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4= +github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= -github.com/holiman/uint256 v1.2.3 h1:K8UWO1HUJpRMXBxbmaY1Y8IAMZC/RsKB+ArEnnK4l5o= -github.com/holiman/uint256 v1.2.3/go.mod h1:SC8Ryt4n+UBbPbIBKaG9zbbDlp4jOru9xFZmPzLUTxw= +github.com/holiman/uint256 v1.3.1 h1:JfTzmih28bittyHM8z360dCjIA9dbPIBlcTI6lmctQs= +github.com/holiman/uint256 v1.3.1/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= -github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ= -github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixHM7Y= -github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= -github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= -github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= -github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= github.com/kennygrant/sanitize v1.2.4 h1:gN25/otpP5vAsO2djbMhF/LQX6R7+O1TB4yv8NzpJ3o= github.com/kennygrant/sanitize v1.2.4/go.mod h1:LGsjYYtgxbetdg5owWB2mpgUL6e2nfw2eObZ0u0qvak= -github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= -github.com/klauspost/compress v1.15.15 h1:EF27CXIuDsYJ6mmvtBRlEuB2UVOqHG1tAXgZ7yIO+lw= -github.com/klauspost/compress v1.15.15/go.mod h1:ZcK2JAFqKOpnBlxcLsJzYfrS9X1akm9fHZNnD9+Vo/4= -github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= -github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc= +github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/leanovate/gopter v0.2.11 h1:vRjThO1EKPb/1NsDXuDrzldR28RLkBflWYcU9CvzWu4= +github.com/leanovate/gopter v0.2.11/go.mod h1:aK3tzZP/C+p1m3SPRE4SYZFGP7jjkuSI4f7Xvpt0S9c= github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= github.com/manifoldco/promptui v0.9.0 h1:3V4HzJk1TtXW1MTZMP7mdlwbBpIinw3HztaIlYthEiA= github.com/manifoldco/promptui v0.9.0/go.mod h1:ka04sppxSGFAtxX0qhlYQjISsg9mR4GWtQEhdbn6Pgg= github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= -github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= -github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= -github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U= -github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= -github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= -github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc= +github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= github.com/miguelmota/go-solidity-sha3 v0.1.1 h1:3Y08sKZDtudtE5kbTBPC9RYJznoSYyWI9VD6mghU0CA= github.com/miguelmota/go-solidity-sha3 v0.1.1/go.mod h1:sax1FvQF+f71j8W1uUHMZn8NxKyl5rYLks2nqj8RFEw= github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= @@ -295,479 +182,183 @@ github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjU github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= +github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= -github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4= -github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc= +github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M= +github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.16.0 h1:yk/hx9hDbrGHovbci4BY+pRMfSuuat626eFsHb7tmT8= -github.com/prometheus/client_golang v1.16.0/go.mod h1:Zsulrv/L9oM40tJ7T815tM89lFEugiJ9HzIqaAx4LKc= -github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/client_model v0.4.0 h1:5lQXD3cAg1OXBf4Wq03gTrXHeaV0TQvGfUooCfx1yqY= -github.com/prometheus/client_model v0.4.0/go.mod h1:oMQmHW1/JoDwqLtg57MGgP/Fb1CJEYF2imWWhWtMkYU= -github.com/prometheus/common v0.44.0 h1:+5BrQJwiBB9xsMygAB3TNvpQKOwlkc25LbISbrdOOfY= -github.com/prometheus/common v0.44.0/go.mod h1:ofAIvZbQ1e/nugmZGz4/qCb9Ap1VoSTIO7x0VV9VvuY= -github.com/prometheus/procfs v0.11.1 h1:xRC8Iq1yyca5ypa9n1EZnWZkt7dwcoRPQwX/5gwaUuI= -github.com/prometheus/procfs v0.11.1/go.mod h1:eesXgaPo1q7lBpVMoMy0ZOFTth9hBn4W/y0/p/ScXhY= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v1.20.5 h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y= +github.com/prometheus/client_golang v1.20.5/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE= +github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= +github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= +github.com/prometheus/common v0.60.1 h1:FUas6GcOw66yB/73KC+BOZoFJmbo/1pojoILArPAaSc= +github.com/prometheus/common v0.60.1/go.mod h1:h0LYf1R1deLSKtD4Vdg8gy4RuOvENW2J/h19V5NADQw= +github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= +github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= github.com/razor-network/goInfo v0.0.0-20200404012835-b5f882ee2288 h1:YDhwtQQyOyzEIfIfB2LYmu63aBL0mdWjnDcXMpWiuc8= github.com/razor-network/goInfo v0.0.0-20200404012835-b5f882ee2288/go.mod h1:vNIP0Qi4Kp5wi+illrG+pyBegM/rUKP/6QTP2lLmaNI= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= -github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= -github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= -github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= -github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= +github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= +github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= +github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/sagikazarmark/locafero v0.6.0 h1:ON7AQg37yzcRPU69mt7gwhFEBwxI6P9T4Qu3N51bwOk= +github.com/sagikazarmark/locafero v0.6.0/go.mod h1:77OmuIc6VTraTXKXIs/uvUxKGUXjE1GbemJYHqdNjX0= +github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= +github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= github.com/saintfish/chardet v0.0.0-20230101081208-5e3ef4b5456d h1:hrujxIzL1woJ7AwssoOcM/tq5JjjG2yYOc8odClEiXA= github.com/saintfish/chardet v0.0.0-20230101081208-5e3ef4b5456d/go.mod h1:uugorj2VCxiV1x+LzaIdVa9b4S4qGAcH6cbhh4qVxOU= github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= -github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8= github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= +github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= +github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= -github.com/spf13/afero v1.9.5 h1:stMpOSZFs//0Lv29HduCmli3GUfpFoF3Y1Q/aXj/wVM= -github.com/spf13/afero v1.9.5/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ= -github.com/spf13/cast v1.5.1 h1:R+kOtfhWQE6TVQzY+4D7wJLBgkdVasCEFxSUBYBYIlA= -github.com/spf13/cast v1.5.1/go.mod h1:b9PdjNptOpzXr7Rq1q9gJML/2cdGQAo69NKzQ10KN48= -github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I= -github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0= -github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk= -github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= +github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= +github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= +github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= +github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= +github.com/spf13/cast v1.7.0 h1:ntdiHjuueXFgm5nzDRdOS4yfT43P5Fnud6DH50rz/7w= +github.com/spf13/cast v1.7.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= +github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM= +github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= -github.com/spf13/viper v1.16.0 h1:rGGH0XDZhdUOryiDWjmIvUSWpbNqisK8Wk0Vyefw8hc= -github.com/spf13/viper v1.16.0/go.mod h1:yg78JgCJcbrQOvV9YLXgkLaZqUidkY9K+Dd1FofRzQg= +github.com/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI= +github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg= github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.1 h1:4VhoImhV/Bm0ToFkXFi8hXNXwpDRZ/ynw3amt82mzq0= -github.com/stretchr/objx v0.5.1/go.mod h1:/iHQpkQwBD6DLUmQ4pE+s1TXdob1mORJ4/UFdrifcy0= -github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= -github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= -github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/supranational/blst v0.3.13 h1:AYeSxdOMacwu7FBmpfloBz5pbFXDmJL33RuwnKtmTjk= +github.com/supranational/blst v0.3.13/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= github.com/temoto/robotstxt v1.1.2 h1:W2pOjSJ6SWvldyEuiFXNxz3xZ8aiWX5LbfDiOFd7Fxg= github.com/temoto/robotstxt v1.1.2/go.mod h1:+1AmkuG3IYkh1kv0d2qEB9Le88ehNO0zwOr3ujewlOo= -github.com/tidwall/gjson v1.16.0 h1:SyXa+dsSPpUlcwEDuKuEBJEz5vzTvOea+9rjyYodQFg= -github.com/tidwall/gjson v1.16.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= +github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY= +github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA= github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4= github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= -github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= -github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= -github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= -github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= +github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= +github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= +github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo= +github.com/tklauser/numcpus v0.9.0/go.mod h1:SN6Nq1O3VychhC1npsWostA+oW+VOQTxZrS604NSRyI= github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= -github.com/urfave/cli/v2 v2.24.1 h1:/QYYr7g0EhwXEML8jO+8OYt5trPnLHS0p3mrgExJ5NU= -github.com/urfave/cli/v2 v2.24.1/go.mod h1:GHupkWPMM0M/sj1a2b4wUrWBPzazNrIjouW6fmdJLxc= +github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs= +github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= -github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw= -github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= -go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= -go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= -go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= +github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= +github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.13.0 h1:mvySKfSWJ+UKUii46M40LOvyWfN0s2U+46/jDd0e6Ck= -golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc= -golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= -golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= -golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= -golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= -golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= -golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g= -golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k= -golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= -golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= -golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= -golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= -golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= -golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= -golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= -golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= -golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= -golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= -golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= -golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= -golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw= +golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U= +golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c h1:7dEasQXItcW1xKJ2+gg5VOiBnqWrJc+rq0DPKyvvdbY= +golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c/go.mod h1:NQtJDoLvd6faHhE7m4T/1IY708gDefGGjR/iUW8yQQ8= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= -golang.org/x/net v0.15.0 h1:ugBLEUaxABaB5AJqW9enI0ACdci2RUd4eP51NTBvuJ8= -golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk= -golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= -golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4= +golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E= -golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= -golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ= +golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o= -golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo= +golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ= golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= -golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= -golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k= -golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= -golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4= -golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM= +golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= -golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= -golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= -golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= -golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= -golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= -google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= -google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= -google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= -google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= -google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= -google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= -google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= -google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= -google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE= -google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= -google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= -google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= -google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= -google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= -google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= -google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= -google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= -google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= -google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= -google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= -google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= -google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= -google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= -google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= -google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= -google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= -google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= -google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= -google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= -google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= -google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= -google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= -google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= -google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= -google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= -google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= -google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= -google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= -google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA= +google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= -gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce h1:+JknDZhAj8YMt7GC73Ei8pv4MzjDUNPHgQWJdtMAaDU= -gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= -honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= -rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= -rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/logger/logger.go b/logger/logger.go index c640041f8..6bb8b2c21 100644 --- a/logger/logger.go +++ b/logger/logger.go @@ -18,25 +18,34 @@ import ( "gopkg.in/natefinch/lumberjack.v2" ) -type StandardLogger struct { - *logrus.Logger +// Logger encapsulates logrus and its dependencies for contextual logging. +type Logger struct { + LogrusInstance *logrus.Logger + address string + client *ethclient.Client + blockMonitor *block.BlockMonitor } -var standardLogger = &StandardLogger{logrus.New()} +// Global logger instance +var globalLogger = NewLogger("", nil, nil) -var Address string -var Epoch uint32 -var BlockNumber *big.Int -var FileName string -var Client *ethclient.Client +// GetLogger returns the global logger instance. +func GetLogger() *Logger { + return globalLogger +} + +// UpdateLogger updates the global logger instance with new parameters. +func UpdateLogger(address string, client *ethclient.Client, blockMonitor *block.BlockMonitor) { + globalLogger.address = address + globalLogger.client = client + globalLogger.blockMonitor = blockMonitor +} func init() { - path.PathUtilsInterface = &path.PathUtils{} - path.OSUtilsInterface = &path.OSUtils{} - InitializeLogger(FileName, types.Configurations{}) + InitializeLogger("", types.Configurations{}) osInfo := goInfo.GetInfo() - standardLogger.WithFields(logrus.Fields{ + globalLogger.LogrusInstance.WithFields(logrus.Fields{ "Operating System": osInfo.OS, "Core": osInfo.Core, "Platform": osInfo.Platform, @@ -47,11 +56,25 @@ func init() { } +//NewLogger initializes a Logger instance with given parameters. +func NewLogger(address string, client *ethclient.Client, blockMonitor *block.BlockMonitor) *Logger { + logger := &Logger{ + LogrusInstance: logrus.New(), + address: address, + client: client, + blockMonitor: blockMonitor, + } + + return logger +} + func InitializeLogger(fileName string, config types.Configurations) { + path.PathUtilsInterface = &path.PathUtils{} + path.OSUtilsInterface = &path.OSUtils{} if fileName != "" { logFilePath, err := path.PathUtilsInterface.GetLogFilePath(fileName) if err != nil { - standardLogger.Fatal("Error in fetching log file path: ", err) + globalLogger.Fatal("Error in fetching log file path: ", err) } lumberJackLogger := &lumberjack.Logger{ @@ -61,131 +84,160 @@ func InitializeLogger(fileName string, config types.Configurations) { MaxAge: config.LogFileMaxAge, } - out := os.Stderr - mw := io.MultiWriter(out, lumberJackLogger) - standardLogger.SetOutput(mw) + mw := io.MultiWriter(os.Stderr, lumberJackLogger) + globalLogger.LogrusInstance.SetOutput(mw) } - standardLogger.Formatter = &logrus.JSONFormatter{} + globalLogger.LogrusInstance.Formatter = &logrus.JSONFormatter{} } -func NewLogger() *StandardLogger { - return standardLogger +// Error logs a simple error message. +func (l *Logger) Error(args ...interface{}) { + epoch, blockNumber := l.updateBlockInfo() + logFields := logrus.Fields{ + "address": l.address, + "epoch": epoch, + "blockNumber": blockNumber, + "version": core.VersionWithMeta, + } + l.LogrusInstance.WithFields(logFields).Errorln(args...) } -func joinString(args ...interface{}) string { - str := "" - for index := 0; index < len(args); index++ { - msg := fmt.Sprintf("%v", args[index]) - str += " " + msg +// Info logs a simple informational message. +func (l *Logger) Info(args ...interface{}) { + epoch, blockNumber := l.updateBlockInfo() + logFields := logrus.Fields{ + "address": l.address, + "epoch": epoch, + "blockNumber": blockNumber, + "version": core.VersionWithMeta, } - return str + l.LogrusInstance.WithFields(logFields).Infoln(args...) } -func (logger *StandardLogger) Error(args ...interface{}) { - SetEpochAndBlockNumber(Client) - var logFields = logrus.Fields{ - "address": Address, - "epoch": Epoch, - "blockNumber": BlockNumber, +// Debug logs a simple debug message. +func (l *Logger) Debug(args ...interface{}) { + epoch, blockNumber := l.updateBlockInfo() + logFields := logrus.Fields{ + "address": l.address, + "epoch": epoch, + "blockNumber": blockNumber, "version": core.VersionWithMeta, } - logger.WithFields(logFields).Errorln(args...) + l.LogrusInstance.WithFields(logFields).Debugln(args...) } -func (logger *StandardLogger) Info(args ...interface{}) { - SetEpochAndBlockNumber(Client) - var logFields = logrus.Fields{ - "address": Address, - "epoch": Epoch, - "blockNumber": BlockNumber, +// Fatal logs a fatal error message and exits the application. +func (l *Logger) Fatal(args ...interface{}) { + epoch, blockNumber := l.updateBlockInfo() + logFields := logrus.Fields{ + "address": l.address, + "epoch": epoch, + "blockNumber": blockNumber, "version": core.VersionWithMeta, } - logger.WithFields(logFields).Infoln(args...) + errMsg := joinString(args) + err := errors.New(errMsg) + l.LogrusInstance.WithFields(logFields).Fatalln(err) } -func (logger *StandardLogger) Debug(args ...interface{}) { - SetEpochAndBlockNumber(Client) - var logFields = logrus.Fields{ - "address": Address, - "epoch": Epoch, - "blockNumber": BlockNumber, +// Warn logs a simple warning message. +func (l *Logger) Warn(args ...interface{}) { + epoch, blockNumber := l.updateBlockInfo() + logFields := logrus.Fields{ + "address": l.address, + "epoch": epoch, + "blockNumber": blockNumber, "version": core.VersionWithMeta, } - logger.WithFields(logFields).Debugln(args...) + l.LogrusInstance.WithFields(logFields).Warnln(args...) } -func (logger *StandardLogger) Fatal(args ...interface{}) { - SetEpochAndBlockNumber(Client) - var logFields = logrus.Fields{ - "address": Address, - "epoch": Epoch, - "blockNumber": BlockNumber, +// Errorf logs a formatted error message. +func (l *Logger) Errorf(format string, args ...interface{}) { + epoch, blockNumber := l.updateBlockInfo() + logFields := logrus.Fields{ + "address": l.address, + "epoch": epoch, + "blockNumber": blockNumber, "version": core.VersionWithMeta, } - errMsg := joinString(args) - err := errors.New(errMsg) - logger.WithFields(logFields).Fatalln(err) + l.LogrusInstance.WithFields(logFields).Errorf(format, args...) } -func (logger *StandardLogger) Errorf(format string, args ...interface{}) { - SetEpochAndBlockNumber(Client) - var logFields = logrus.Fields{ - "address": Address, - "epoch": Epoch, - "blockNumber": BlockNumber, +// Infof logs a formatted informational message. +func (l *Logger) Infof(format string, args ...interface{}) { + epoch, blockNumber := l.updateBlockInfo() + logFields := logrus.Fields{ + "address": l.address, + "epoch": epoch, + "blockNumber": blockNumber, "version": core.VersionWithMeta, } - logger.WithFields(logFields).Errorf(format, args...) + l.LogrusInstance.WithFields(logFields).Infof(format, args...) } -func (logger *StandardLogger) Infof(format string, args ...interface{}) { - SetEpochAndBlockNumber(Client) - var logFields = logrus.Fields{ - "address": Address, - "epoch": Epoch, - "blockNumber": BlockNumber, +// Debugf logs a formatted debug message. +func (l *Logger) Debugf(format string, args ...interface{}) { + epoch, blockNumber := l.updateBlockInfo() + logFields := logrus.Fields{ + "address": l.address, + "epoch": epoch, + "blockNumber": blockNumber, "version": core.VersionWithMeta, } - logger.WithFields(logFields).Infof(format, args...) + l.LogrusInstance.WithFields(logFields).Debugf(format, args...) } -func (logger *StandardLogger) Debugf(format string, args ...interface{}) { - SetEpochAndBlockNumber(Client) - var logFields = logrus.Fields{ - "address": Address, - "epoch": Epoch, - "blockNumber": BlockNumber, +// Fatalf logs a formatted fatal error message and exits the application. +func (l *Logger) Fatalf(format string, args ...interface{}) { + epoch, blockNumber := l.updateBlockInfo() + logFields := logrus.Fields{ + "address": l.address, + "epoch": epoch, + "blockNumber": blockNumber, "version": core.VersionWithMeta, } - logger.WithFields(logFields).Debugf(format, args...) + errMsg := joinString(args...) + err := errors.New(errMsg) + l.LogrusInstance.WithFields(logFields).Fatalf(format, err) } -func (logger *StandardLogger) Fatalf(format string, args ...interface{}) { - SetEpochAndBlockNumber(Client) - var logFields = logrus.Fields{ - "address": Address, - "epoch": Epoch, - "blockNumber": BlockNumber, +// Warnf logs a formatted warning message. +func (l *Logger) Warnf(format string, args ...interface{}) { + epoch, blockNumber := l.updateBlockInfo() + logFields := logrus.Fields{ + "address": l.address, + "epoch": epoch, + "blockNumber": blockNumber, "version": core.VersionWithMeta, } - errMsg := joinString(args) - err := errors.New(errMsg) - logger.WithFields(logFields).Fatalf(format, err) + l.LogrusInstance.WithFields(logFields).Warnf(format, args...) } -func SetEpochAndBlockNumber(client *ethclient.Client) { - if client != nil { - latestBlock := block.GetLatestBlock() - if latestBlock != nil { - BlockNumber = latestBlock.Number - epoch := latestBlock.Time / core.EpochLength - Epoch = uint32(epoch) - } +// joinString concatenates multiple arguments into a single string. +func joinString(args ...interface{}) string { + str := "" + for index := 0; index < len(args); index++ { + msg := fmt.Sprintf("%v", args[index]) + str += " " + msg } + return str } -func SetLoggerParameters(client *ethclient.Client, address string) { - Address = address - Client = client - go block.CalculateLatestBlock(client) +// SetLogLevel sets the log level for the logger instance. +func (l *Logger) SetLogLevel(level logrus.Level) { + l.LogrusInstance.SetLevel(level) +} + +// updateBlockInfo fetches block info from the BlockMonitor. +func (l *Logger) updateBlockInfo() (uint32, *big.Int) { + if l.blockMonitor == nil { + return 0, nil + } + latestBlock := l.blockMonitor.GetLatestBlock() + if latestBlock != nil { + epoch := uint32(latestBlock.Time / core.EpochLength) + return epoch, latestBlock.Number + } + return 0, nil } diff --git a/rpc/rpc.go b/rpc/rpc.go new file mode 100644 index 000000000..f187a4d3d --- /dev/null +++ b/rpc/rpc.go @@ -0,0 +1,247 @@ +package rpc + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/ethereum/go-ethereum/log" + "github.com/sirupsen/logrus" + "os" + "path/filepath" + "razor/core" + "razor/path" + "sort" + "strings" + "sync" + "time" +) + +func (m *RPCManager) calculateMetrics(endpoint *RPCEndpoint) error { + ctx, cancel := context.WithTimeout(context.Background(), core.EndpointsContextTimeout*time.Second) + defer cancel() + + client, err := ethclient.DialContext(ctx, endpoint.URL) + if err != nil { + return fmt.Errorf("failed to connect to RPC: %w", err) + } + + start := time.Now() + blockNumber, err := m.fetchBlockNumberWithTimeout(ctx, client) + if err != nil { + if errors.Is(err, context.DeadlineExceeded) { + return fmt.Errorf("RPC call timed out: %w", err) + } + return fmt.Errorf("RPC call failed: %w", err) + } + latency := time.Since(start).Seconds() + + endpoint.BlockNumber = blockNumber + endpoint.Latency = latency + endpoint.Client = client + + return nil +} + +// updateAndSortEndpoints calculates metrics and sorts the endpoints +func (m *RPCManager) updateAndSortEndpoints() error { + if len(m.Endpoints) == 0 { + return fmt.Errorf("no endpoints available to update") + } + + var wg sync.WaitGroup + logrus.Debug("Starting concurrent metrics calculation for all endpoints...") + + for _, endpoint := range m.Endpoints { + wg.Add(1) + go func(ep *RPCEndpoint) { + defer wg.Done() + if err := m.calculateMetrics(ep); err != nil { + logrus.Errorf("Error calculating metrics for endpoint %s: %v", ep.URL, err) + } + }(endpoint) + } + wg.Wait() + + log.Debug("Concurrent metrics calculation complete. Sorting endpoints...") + + m.mutex.Lock() + defer m.mutex.Unlock() + + sort.Slice(m.Endpoints, func(i, j int) bool { + if m.Endpoints[i].BlockNumber == m.Endpoints[j].BlockNumber { + return m.Endpoints[i].Latency < m.Endpoints[j].Latency + } + return m.Endpoints[i].BlockNumber > m.Endpoints[j].BlockNumber + }) + + // Update the best RPC endpoint after sorting + m.BestEndpoint = m.Endpoints[0] + + logrus.Infof("Best RPC endpoint updated: %s (BlockNumber: %d, Latency: %.2f)", + m.BestEndpoint.URL, m.BestEndpoint.BlockNumber, m.BestEndpoint.Latency) + + return nil +} + +// RefreshEndpoints will update and sort the endpoints. +func (m *RPCManager) RefreshEndpoints() error { + if err := m.updateAndSortEndpoints(); err != nil { + return fmt.Errorf("failed to refresh endpoints: %w", err) + } + logrus.Infof("Endpoints refreshed successfully") + return nil +} + +func InitializeRPCManager(provider string) (*RPCManager, error) { + defaultPath, err := path.PathUtilsInterface.GetDefaultPath() + if err != nil { + return nil, fmt.Errorf("failed to get .razor path: %w", err) + } + + endpointsFile := filepath.Join(defaultPath, "endpoints.json") + fileData, err := os.ReadFile(endpointsFile) + if err != nil { + return nil, fmt.Errorf("failed to read endpoints.json: %w", err) + } + + // Unmarshal the JSON file into a list of RPC endpoints + var rpcEndpointsList []string + err = json.Unmarshal(fileData, &rpcEndpointsList) + if err != nil { + return nil, fmt.Errorf("failed to unmarshal endpoints.json: %w", err) + } + + // Normalize provider input and check if it's already in the list + provider = strings.TrimSpace(provider) // Trim whitespace from the input + providerFound := false + for _, endpoint := range rpcEndpointsList { + if endpoint == provider { + providerFound = true + break + } + } + + // If the provider is not found, add it to the list + if !providerFound && provider != "" { + logrus.Infof("Adding user-provided endpoint: %s", provider) + rpcEndpointsList = append(rpcEndpointsList, provider) + } + + // Initialize the RPC endpoints + rpcEndpoints := make([]*RPCEndpoint, len(rpcEndpointsList)) + for i, url := range rpcEndpointsList { + rpcEndpoints[i] = &RPCEndpoint{URL: url} + } + + rpcManager := &RPCManager{ + Endpoints: rpcEndpoints, + } + + // Pre-calculate metrics and set the best client on initialization + if err := rpcManager.updateAndSortEndpoints(); err != nil { + return nil, fmt.Errorf("failed to initialize RPC Manager: %w", err) + } + + return rpcManager, nil +} + +func (m *RPCManager) GetBestRPCClient() (*ethclient.Client, error) { + m.mutex.RLock() + defer m.mutex.RUnlock() + + if m.BestEndpoint.Client == nil { + return nil, fmt.Errorf("no best RPC client available") + } + return m.BestEndpoint.Client, nil +} + +// GetBestEndpointURL returns the URL of the best endpoint +func (m *RPCManager) GetBestEndpointURL() (string, error) { + m.mutex.RLock() + defer m.mutex.RUnlock() + + if m.BestEndpoint == nil { + return "", fmt.Errorf("no best endpoint available") + } + return m.BestEndpoint.URL, nil +} + +// SwitchToNextBestRPCClient switches to the next best available client after the current best client. +// If no valid next best client is found, it retains the current best client. +func (m *RPCManager) SwitchToNextBestRPCClient() (bool, error) { + m.mutex.Lock() + defer m.mutex.Unlock() + + // If there are fewer than 2 endpoints, there are no alternate clients to switch to. + if len(m.Endpoints) < 2 { + logrus.Warn("No alternate RPC clients available. Retaining the current best client.") + return false, nil + } + + // Find the index of the current best client + var currentIndex = -1 + for i, endpoint := range m.Endpoints { + if endpoint.Client == m.BestEndpoint.Client { + currentIndex = i + break + } + } + + // If the current client is not found (which is rare), return an error + if currentIndex == -1 { + return false, fmt.Errorf("current best client not found in the list of endpoints") + } + + // Iterate through the remaining endpoints to find a valid next best client + for i := 1; i < len(m.Endpoints); i++ { + nextIndex := (currentIndex + i) % len(m.Endpoints) + nextEndpoint := m.Endpoints[nextIndex] + + // Check if we can connect to the next endpoint + ctx, cancel := context.WithTimeout(context.Background(), core.EndpointsContextTimeout*time.Second) + + client, err := ethclient.DialContext(ctx, nextEndpoint.URL) + if err != nil { + cancel() + logrus.Errorf("Failed to connect to RPC endpoint %s: %v", nextEndpoint.URL, err) + continue + } + + // Try fetching block number to validate the endpoint + _, err = m.fetchBlockNumberWithTimeout(ctx, client) + if err != nil { + cancel() + logrus.Errorf("Failed to fetch block number for endpoint %s: %v", nextEndpoint.URL, err) + continue + } + + // Cancel the context after the operations complete. + cancel() + + // Successfully connected and validated, update the best client and endpoint + // (Make sure that the client is correctly associated with the endpoint.) + nextEndpoint.Client = client + m.BestEndpoint = nextEndpoint + + logrus.Infof("Switched to the next best RPC endpoint: %s (BlockNumber: %d, Latency: %.2f)", + m.BestEndpoint.URL, m.BestEndpoint.BlockNumber, m.BestEndpoint.Latency) + return true, nil + } + + // If no valid endpoint is found, retain the current best client + logrus.Warn("No valid next-best RPC client found. Retaining the current best client.") + return false, nil +} + +func (m *RPCManager) fetchBlockNumberWithTimeout(ctx context.Context, client *ethclient.Client) (uint64, error) { + blockNumber, err := client.BlockNumber(ctx) + if err != nil { + if errors.Is(err, context.DeadlineExceeded) { + return 0, fmt.Errorf("RPC call timed out: %w", err) + } + return 0, fmt.Errorf("RPC call failed: %w", err) + } + return blockNumber, nil +} diff --git a/rpc/rpc_struct.go b/rpc/rpc_struct.go new file mode 100644 index 000000000..6957c9d9a --- /dev/null +++ b/rpc/rpc_struct.go @@ -0,0 +1,25 @@ +package rpc + +import ( + "context" + "github.com/ethereum/go-ethereum/ethclient" + "sync" +) + +type RPCEndpoint struct { + URL string + BlockNumber uint64 + Latency float64 + Client *ethclient.Client +} + +type RPCManager struct { + Endpoints []*RPCEndpoint + mutex sync.RWMutex + BestEndpoint *RPCEndpoint // Holds the URL to current best RPC client +} + +type RPCParameters struct { + Ctx context.Context // Context with timeout for handling unresponsive RPC calls + RPCManager *RPCManager // RPC manager for client selection and contract calls +} diff --git a/rpc/rpc_test.go b/rpc/rpc_test.go new file mode 100644 index 000000000..f61878221 --- /dev/null +++ b/rpc/rpc_test.go @@ -0,0 +1,320 @@ +package rpc + +import ( + "encoding/json" + "fmt" + "net/http" + "net/http/httptest" + "strconv" + "testing" + "time" +) + +// decodeRPCRequest decodes the JSON–RPC request body into a map. +func decodeRPCRequest(r *http.Request) (map[string]interface{}, error) { + var req map[string]interface{} + err := json.NewDecoder(r.Body).Decode(&req) + return req, err +} + +// writeRPCResponse writes the provided response as JSON with the appropriate header. +func writeRPCResponse(w http.ResponseWriter, response map[string]interface{}) { + w.Header().Set("Content-Type", "application/json") + _ = json.NewEncoder(w).Encode(response) +} + +// jsonRPCHandler simulates an Ethereum JSON–RPC endpoint that returns block number 100. +func jsonRPCHandler(w http.ResponseWriter, r *http.Request) { + req, err := decodeRPCRequest(r) + if err != nil { + http.Error(w, "bad request", http.StatusBadRequest) + return + } + + // Verify that the method is "eth_blockNumber". + if method, ok := req["method"].(string); !ok || method != "eth_blockNumber" { + http.Error(w, "unsupported method", http.StatusBadRequest) + return + } + + // Build and send a JSON–RPC response with block number 100 (hex "0x64"). + resp := map[string]interface{}{ + "jsonrpc": "2.0", + "id": req["id"], + "result": "0x64", + } + writeRPCResponse(w, resp) +} + +// errorRPCHandler simulates a failing RPC endpoint by returning status 500. +func errorRPCHandler(w http.ResponseWriter, r *http.Request) { + http.Error(w, "Internal Server Error", http.StatusInternalServerError) +} + +// delayedJSONRPCHandler returns a handler that simulates a delay and returns the given block number. +func delayedJSONRPCHandler(delay time.Duration, blockNumber uint64) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Simulate network delay. + time.Sleep(delay) + + req, err := decodeRPCRequest(r) + if err != nil { + http.Error(w, "bad request", http.StatusBadRequest) + return + } + + hexBlock := "0x" + strconv.FormatUint(blockNumber, 16) + resp := map[string]interface{}{ + "jsonrpc": "2.0", + "id": req["id"], + "result": hexBlock, + } + writeRPCResponse(w, resp) + } +} + +// makeHandler returns an HTTP handler that responds with the provided block number. +func makeHandler(blockNumber uint64) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + req, err := decodeRPCRequest(r) + if err != nil { + http.Error(w, "bad request", http.StatusBadRequest) + return + } + hexBlock := fmt.Sprintf("0x%x", blockNumber) + resp := map[string]interface{}{ + "jsonrpc": "2.0", + "id": req["id"], + "result": hexBlock, + } + writeRPCResponse(w, resp) + } +} + +// createManagerFromServers creates an RPCManager from a list of test servers. +func createManagerFromServers(servers ...*httptest.Server) *RPCManager { + endpoints := make([]*RPCEndpoint, len(servers)) + for i, s := range servers { + endpoints[i] = &RPCEndpoint{URL: s.URL} + } + return &RPCManager{Endpoints: endpoints} +} + +// TestRPCManagerWithJSONRPC verifies that RefreshEndpoints correctly pings multiple endpoints, +// updates their metrics, and selects the best (fastest healthy) endpoint. +func TestRPCManagerWithJSONRPC(t *testing.T) { + // Create three test servers: + // ts1: healthy with no artificial delay (using jsonRPCHandler which has block number 100 defined) + ts1 := httptest.NewServer(http.HandlerFunc(jsonRPCHandler)) + t.Cleanup(func() { ts1.Close() }) + + // ts2: healthy but with a 200ms delay (using delayedJSONRPCHandler returning block 100) + ts2 := httptest.NewServer(delayedJSONRPCHandler(200*time.Millisecond, 100)) + t.Cleanup(func() { ts2.Close() }) + + // ts3: unhealthy (using errorRPCHandler) + ts3 := httptest.NewServer(http.HandlerFunc(errorRPCHandler)) + t.Cleanup(func() { ts3.Close() }) + + // Create an RPCManager with all three endpoints. + manager := createManagerFromServers(ts1, ts2, ts3) + + // Refresh endpoints so that the manager pings each endpoint. + if err := manager.RefreshEndpoints(); err != nil { + t.Fatalf("RefreshEndpoints failed: %v", err) + } + + // Since ts1 and ts2 are healthy and return the same block number (100), + // the tie-breaker is latency. ts1 should be faster (no delay) than ts2. + bestURL, err := manager.GetBestEndpointURL() + if err != nil { + t.Fatalf("GetBestEndpointURL failed: %v", err) + } + + if bestURL != ts1.URL { + t.Errorf("Expected best endpoint to be %s, got %s", ts1.URL, bestURL) + } + + if manager.BestEndpoint.BlockNumber != 100 { + t.Errorf("Expected block number 100, got %d", manager.BestEndpoint.BlockNumber) + } + + if manager.BestEndpoint.Latency <= 0 { + t.Errorf("Expected positive latency, got %f", manager.BestEndpoint.Latency) + } +} + +// TestRPCManagerWithDelayedJSONRPC verifies that a delayed response is handled correctly, +// with latency measured properly and block number updated. +func TestRPCManagerWithDelayedJSONRPC(t *testing.T) { + delay := 2 * time.Second + blockNumber := uint64(150) + + ts := httptest.NewServer(delayedJSONRPCHandler(delay, blockNumber)) + t.Cleanup(func() { ts.Close() }) + + manager := &RPCManager{ + Endpoints: []*RPCEndpoint{ + {URL: ts.URL}, + }, + } + + start := time.Now() + if err := manager.RefreshEndpoints(); err != nil { + t.Fatalf("RefreshEndpoints failed: %v", err) + } + elapsed := time.Since(start) + if elapsed < delay { + t.Errorf("Expected elapsed time at least %v, got %v", delay, elapsed) + } + + bestURL, err := manager.GetBestEndpointURL() + if err != nil { + t.Fatalf("GetBestEndpointURL failed: %v", err) + } + if bestURL != ts.URL { + t.Errorf("Expected best endpoint URL %s, got %s", ts.URL, bestURL) + } + + if manager.BestEndpoint.BlockNumber != blockNumber { + t.Errorf("Expected block number %d, got %d", blockNumber, manager.BestEndpoint.BlockNumber) + } + + // Ensure the measured latency reflects the simulated delay. + if manager.BestEndpoint.Latency < delay.Seconds() { + t.Errorf("Expected measured latency at least %f, got %f", delay.Seconds(), manager.BestEndpoint.Latency) + } +} + +// TestSwitchToNextBestClient verifies the behavior of SwitchToNextBestRPCClient under various conditions. +func TestSwitchToNextBestClient(t *testing.T) { + t.Run("switches when best endpoint fails", func(t *testing.T) { + // Create three test servers with different block numbers. + ts1 := httptest.NewServer(makeHandler(100)) + t.Cleanup(func() { ts1.Close() }) + + ts2 := httptest.NewServer(makeHandler(120)) + // Do not defer ts2.Close() here to simulate its failure. + + ts3 := httptest.NewServer(makeHandler(110)) + t.Cleanup(func() { ts3.Close() }) + + manager := createManagerFromServers(ts1, ts2, ts3) + + if err := manager.RefreshEndpoints(); err != nil { + t.Fatalf("RefreshEndpoints failed: %v", err) + } + + bestURL, err := manager.GetBestEndpointURL() + if err != nil { + t.Fatalf("GetBestEndpointURL failed: %v", err) + } + if bestURL != ts2.URL { + t.Fatalf("Expected best endpoint to be %s, got %s", ts2.URL, bestURL) + } + + // Simulate failure of the best endpoint. + ts2.Close() + time.Sleep(100 * time.Millisecond) + + switched, err := manager.SwitchToNextBestRPCClient() + if err != nil { + t.Fatalf("SwitchToNextBestRPCClient returned error: %v", err) + } + if !switched { + t.Fatal("Expected switch to next best endpoint, but no switch occurred") + } + + newBestURL, err := manager.GetBestEndpointURL() + if err != nil { + t.Fatalf("GetBestEndpointURL failed after switch: %v", err) + } + if newBestURL != ts3.URL { + t.Errorf("Expected new best endpoint to be %s, got %s", ts3.URL, newBestURL) + } + if manager.BestEndpoint.BlockNumber != 110 { + t.Errorf("Expected block number 110 for new best endpoint, got %d", manager.BestEndpoint.BlockNumber) + } + }) + + t.Run("does not switch when the rest of the endpoints are not healthy", func(t *testing.T) { + ts1 := httptest.NewServer(makeHandler(100)) + ts2 := httptest.NewServer(makeHandler(120)) + ts3 := httptest.NewServer(makeHandler(110)) + t.Cleanup(func() { ts1.Close() }) + t.Cleanup(func() { ts2.Close() }) + t.Cleanup(func() { ts3.Close() }) + + manager := createManagerFromServers(ts1, ts2, ts3) + + if err := manager.RefreshEndpoints(); err != nil { + t.Fatalf("RefreshEndpoints failed: %v", err) + } + + bestURL, err := manager.GetBestEndpointURL() + if err != nil { + t.Fatalf("GetBestEndpointURL failed: %v", err) + } + if bestURL != ts2.URL { + t.Fatalf("Expected best endpoint to be %s, got %s", ts2.URL, bestURL) + } + + // Simulate failure of ts1 and ts3. + ts1.Close() + ts3.Close() + time.Sleep(100 * time.Millisecond) + + switched, err := manager.SwitchToNextBestRPCClient() + if err != nil { + t.Fatalf("SwitchToNextBestRPCClient returned error: %v", err) + } + if switched { + t.Error("Did not expect a switch when the alternative endpoints are unhealthy") + } + + newBestURL, err := manager.GetBestEndpointURL() + if err != nil { + t.Fatalf("GetBestEndpointURL failed after attempted switch: %v", err) + } + if newBestURL != ts2.URL { + t.Errorf("Expected best endpoint to remain %s, got %s", ts2.URL, newBestURL) + } + }) + + t.Run("returns false when only one endpoint is available", func(t *testing.T) { + ts1 := httptest.NewServer(makeHandler(120)) + t.Cleanup(func() { ts1.Close() }) + + manager := createManagerFromServers(ts1) + if err := manager.RefreshEndpoints(); err != nil { + t.Fatalf("RefreshEndpoints failed: %v", err) + } + + switched, err := manager.SwitchToNextBestRPCClient() + if err != nil { + t.Fatalf("SwitchToNextBestRPCClient returned error: %v", err) + } + if switched { + t.Error("Expected no switch when only one endpoint is available") + } + }) + + t.Run("returns error when current best client is not found in the list", func(t *testing.T) { + ts1 := httptest.NewServer(makeHandler(100)) + ts2 := httptest.NewServer(makeHandler(120)) + t.Cleanup(func() { ts1.Close() }) + t.Cleanup(func() { ts2.Close() }) + + manager := createManagerFromServers(ts1, ts2) + if err := manager.RefreshEndpoints(); err != nil { + t.Fatalf("RefreshEndpoints failed: %v", err) + } + + // Simulate a scenario where the current best client is not in the endpoints list. + manager.BestEndpoint = &RPCEndpoint{URL: "http://nonexistent"} + _, err := manager.SwitchToNextBestRPCClient() + if err == nil { + t.Error("Expected an error when current best client is not found, but got nil") + } + }) +} diff --git a/utils/asset.go b/utils/asset.go index 7f3602a41..7c66abfb3 100644 --- a/utils/asset.go +++ b/utils/asset.go @@ -11,13 +11,13 @@ import ( "razor/core/types" "razor/path" "razor/pkg/bindings" + "razor/rpc" "regexp" "strconv" "strings" "sync" "time" - "github.com/avast/retry-go" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/ethclient" "github.com/tidwall/gjson" @@ -29,34 +29,30 @@ func (*UtilsStruct) GetCollectionManagerWithOpts(client *ethclient.Client) (*bin return UtilsInterface.GetCollectionManager(client), UtilsInterface.GetOptions() } -func (*UtilsStruct) GetNumCollections(client *ethclient.Client) (uint16, error) { - var ( - numCollections uint16 - err error - ) - err = retry.Do( - func() error { - numCollections, err = AssetManagerInterface.GetNumCollections(client) - if err != nil { - log.Error("Error in fetching numCollections.... Retrying") - return err - } - return nil - }, RetryInterface.RetryAttempts(core.MaxRetries)) +func (*UtilsStruct) GetNumCollections(rpcParameters rpc.RPCParameters) (uint16, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, AssetManagerInterface, "GetNumCollections") if err != nil { return 0, err } - return numCollections, nil + return returnedValues[0].Interface().(uint16), nil } -func (*UtilsStruct) GetJobs(client *ethclient.Client) ([]bindings.StructsJob, error) { +func (*UtilsStruct) GetNumJobs(rpcParameters rpc.RPCParameters) (uint16, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, AssetManagerInterface, "GetNumJobs") + if err != nil { + return 0, err + } + return returnedValues[0].Interface().(uint16), nil +} + +func (*UtilsStruct) GetJobs(rpcParameters rpc.RPCParameters) ([]bindings.StructsJob, error) { var jobs []bindings.StructsJob - numJobs, err := AssetManagerInterface.GetNumJobs(client) + numJobs, err := UtilsInterface.GetNumJobs(rpcParameters) if err != nil { return nil, err } for i := 1; i <= int(numJobs); i++ { - job, err := UtilsInterface.GetActiveJob(client, uint16(i)) + job, err := UtilsInterface.GetActiveJob(rpcParameters, uint16(i)) if err != nil { return nil, err } @@ -65,34 +61,22 @@ func (*UtilsStruct) GetJobs(client *ethclient.Client) ([]bindings.StructsJob, er return jobs, nil } -func (*UtilsStruct) GetNumActiveCollections(client *ethclient.Client) (uint16, error) { - var ( - numActiveAssets uint16 - err error - ) - err = retry.Do( - func() error { - numActiveAssets, err = AssetManagerInterface.GetNumActiveCollections(client) - if err != nil { - log.Error("Error in fetching active assets.... Retrying") - return err - } - return nil - }, RetryInterface.RetryAttempts(core.MaxRetries)) +func (*UtilsStruct) GetNumActiveCollections(rpcParameters rpc.RPCParameters) (uint16, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, AssetManagerInterface, "GetNumActiveCollections") if err != nil { return 0, err } - return numActiveAssets, nil + return returnedValues[0].Interface().(uint16), nil } -func (*UtilsStruct) GetAllCollections(client *ethclient.Client) ([]bindings.StructsCollection, error) { +func (*UtilsStruct) GetAllCollections(rpcParameters rpc.RPCParameters) ([]bindings.StructsCollection, error) { var collections []bindings.StructsCollection - numCollections, err := UtilsInterface.GetNumCollections(client) + numCollections, err := UtilsInterface.GetNumCollections(rpcParameters) if err != nil { return nil, err } for i := 1; i <= int(numCollections); i++ { - collection, err := AssetManagerInterface.GetCollection(client, uint16(i)) + collection, err := UtilsInterface.GetCollection(rpcParameters, uint16(i)) if err != nil { return nil, err } @@ -101,61 +85,45 @@ func (*UtilsStruct) GetAllCollections(client *ethclient.Client) ([]bindings.Stru return collections, nil } -func (*UtilsStruct) GetCollection(client *ethclient.Client, collectionId uint16) (bindings.StructsCollection, error) { - var ( - collection bindings.StructsCollection - err error - ) - err = retry.Do( - func() error { - collection, err = AssetManagerInterface.GetCollection(client, collectionId) - if err != nil { - log.Error("Error in fetching collection.... Retrying") - return err - } - return nil - }, RetryInterface.RetryAttempts(core.MaxRetries)) +func (*UtilsStruct) GetCollection(rpcParameters rpc.RPCParameters, collectionId uint16) (bindings.StructsCollection, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, AssetManagerInterface, "GetCollection", collectionId) if err != nil { return bindings.StructsCollection{}, err } - return collection, nil + return returnedValues[0].Interface().(bindings.StructsCollection), nil } -func (*UtilsStruct) GetActiveCollectionIds(client *ethclient.Client) ([]uint16, error) { - var ( - activeCollectionIds []uint16 - err error - ) - err = retry.Do( - func() error { - activeCollectionIds, err = AssetManagerInterface.GetActiveCollections(client) - if err != nil { - log.Error("Error in fetching active assets.... Retrying") - return err - } - return nil - }, RetryInterface.RetryAttempts(core.MaxRetries)) +func (*UtilsStruct) GetActiveCollectionIds(rpcParameters rpc.RPCParameters) ([]uint16, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, AssetManagerInterface, "GetActiveCollections") if err != nil { return nil, err } - return activeCollectionIds, nil + return returnedValues[0].Interface().([]uint16), nil +} + +func (*UtilsStruct) GetActiveStatus(rpcParameters rpc.RPCParameters, id uint16) (bool, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, AssetManagerInterface, "GetActiveStatus", id) + if err != nil { + return false, err + } + return returnedValues[0].Interface().(bool), nil } -func (*UtilsStruct) GetAggregatedDataOfCollection(client *ethclient.Client, collectionId uint16, epoch uint32, commitParams *types.CommitParams) (*big.Int, error) { +func (*UtilsStruct) GetAggregatedDataOfCollection(rpcParameters rpc.RPCParameters, collectionId uint16, epoch uint32, commitParams *types.CommitParams) (*big.Int, error) { activeCollection, err := UtilsInterface.GetActiveCollection(commitParams.CollectionsCache, collectionId) if err != nil { log.Error(err) return nil, err } //Supply previous epoch to Aggregate in case if last reported value is required. - collectionData, aggregationError := UtilsInterface.Aggregate(client, epoch-1, activeCollection, commitParams) + collectionData, aggregationError := UtilsInterface.Aggregate(rpcParameters, epoch-1, activeCollection, commitParams) if aggregationError != nil { return nil, aggregationError } return collectionData, nil } -func (*UtilsStruct) Aggregate(client *ethclient.Client, previousEpoch uint32, collection bindings.StructsCollection, commitParams *types.CommitParams) (*big.Int, error) { +func (*UtilsStruct) Aggregate(rpcParameters rpc.RPCParameters, previousEpoch uint32, collection bindings.StructsCollection, commitParams *types.CommitParams) (*big.Int, error) { var jobs []bindings.StructsJob var overriddenJobIds []uint16 @@ -184,7 +152,7 @@ func (*UtilsStruct) Aggregate(client *ethclient.Client, previousEpoch uint32, co } // Overriding the jobs from contracts with official jobs present in asset.go - overrideJobs, overriddenJobIdsFromJSONfile := UtilsInterface.HandleOfficialJobsFromJSONFile(client, collection, dataString, commitParams) + overrideJobs, overriddenJobIdsFromJSONfile := UtilsInterface.HandleOfficialJobsFromJSONFile(collection, dataString, commitParams) jobs = append(jobs, overrideJobs...) overriddenJobIds = append(overriddenJobIds, overriddenJobIdsFromJSONfile...) @@ -213,7 +181,7 @@ func (*UtilsStruct) Aggregate(client *ethclient.Client, previousEpoch uint32, co } dataToCommit, weight := UtilsInterface.GetDataToCommitFromJobs(jobs, commitParams) if len(dataToCommit) == 0 { - prevCommitmentData, err := UtilsInterface.FetchPreviousValue(client, previousEpoch, collection.Id) + prevCommitmentData, err := UtilsInterface.FetchPreviousValue(rpcParameters, previousEpoch, collection.Id) if err != nil { return nil, err } @@ -222,24 +190,12 @@ func (*UtilsStruct) Aggregate(client *ethclient.Client, previousEpoch uint32, co return performAggregation(dataToCommit, weight, collection.AggregationMethod) } -func (*UtilsStruct) GetActiveJob(client *ethclient.Client, jobId uint16) (bindings.StructsJob, error) { - var ( - job bindings.StructsJob - err error - ) - err = retry.Do( - func() error { - job, err = AssetManagerInterface.Jobs(client, jobId) - if err != nil { - log.Errorf("Error in fetching job %d.... Retrying", jobId) - return err - } - return nil - }, RetryInterface.RetryAttempts(core.MaxRetries)) +func (*UtilsStruct) GetActiveJob(rpcParameters rpc.RPCParameters, jobId uint16) (bindings.StructsJob, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, AssetManagerInterface, "Jobs", jobId) if err != nil { return bindings.StructsJob{}, err } - return job, nil + return returnedValues[0].Interface().(bindings.StructsJob), nil } func (*UtilsStruct) GetActiveCollection(collectionsCache *cache.CollectionsCache, collectionId uint16) (bindings.StructsCollection, error) { @@ -360,10 +316,10 @@ func (*UtilsStruct) GetDataToCommitFromJob(job bindings.StructsJob, commitParams return MultiplyWithPower(datum, job.Power), err } -func (*UtilsStruct) GetAssignedCollections(client *ethclient.Client, numActiveCollections uint16, seed []byte) (map[int]bool, []*big.Int, error) { +func (*UtilsStruct) GetAssignedCollections(rpcParameters rpc.RPCParameters, numActiveCollections uint16, seed []byte) (map[int]bool, []*big.Int, error) { assignedCollections := make(map[int]bool) var seqAllottedCollections []*big.Int - toAssign, err := UtilsInterface.ToAssign(client) + toAssign, err := UtilsInterface.ToAssign(rpcParameters) if err != nil { return nil, nil, err } @@ -375,64 +331,28 @@ func (*UtilsStruct) GetAssignedCollections(client *ethclient.Client, numActiveCo return assignedCollections, seqAllottedCollections, nil } -func (*UtilsStruct) GetLeafIdOfACollection(client *ethclient.Client, collectionId uint16) (uint16, error) { - var ( - leafId uint16 - err error - ) - err = retry.Do( - func() error { - leafId, err = AssetManagerInterface.GetLeafIdOfACollection(client, collectionId) - if err != nil { - log.Error("Error in fetching collection id.... Retrying") - return err - } - return nil - }, RetryInterface.RetryAttempts(core.MaxRetries)) +func (*UtilsStruct) GetLeafIdOfACollection(rpcParameters rpc.RPCParameters, collectionId uint16) (uint16, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, AssetManagerInterface, "GetLeafIdOfACollection", collectionId) if err != nil { return 0, err } - return leafId, nil + return returnedValues[0].Interface().(uint16), nil } -func (*UtilsStruct) GetCollectionIdFromIndex(client *ethclient.Client, medianIndex uint16) (uint16, error) { - var ( - collectionId uint16 - err error - ) - err = retry.Do( - func() error { - collectionId, err = AssetManagerInterface.GetCollectionIdFromIndex(client, medianIndex) - if err != nil { - log.Error("Error in fetching collection id.... Retrying") - return err - } - return nil - }, RetryInterface.RetryAttempts(core.MaxRetries)) +func (*UtilsStruct) GetCollectionIdFromIndex(rpcParameters rpc.RPCParameters, medianIndex uint16) (uint16, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, AssetManagerInterface, "GetCollectionIdFromIndex", medianIndex) if err != nil { return 0, err } - return collectionId, nil + return returnedValues[0].Interface().(uint16), nil } -func (*UtilsStruct) GetCollectionIdFromLeafId(client *ethclient.Client, leafId uint16) (uint16, error) { - var ( - collectionId uint16 - err error - ) - err = retry.Do( - func() error { - collectionId, err = AssetManagerInterface.GetCollectionIdFromLeafId(client, leafId) - if err != nil { - log.Error("Error in fetching collection id.... Retrying") - return err - } - return nil - }, RetryInterface.RetryAttempts(core.MaxRetries)) +func (*UtilsStruct) GetCollectionIdFromLeafId(rpcParameters rpc.RPCParameters, leafId uint16) (uint16, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, AssetManagerInterface, "GetCollectionIdFromLeafId", leafId) if err != nil { return 0, err } - return collectionId, nil + return returnedValues[0].Interface().(uint16), nil } func GetCustomJobsFromJSONFile(collection string, jsonFileData string) []bindings.StructsJob { @@ -486,7 +406,7 @@ func ConvertCustomJobToStructJob(customJob types.CustomJob) bindings.StructsJob } } -func (*UtilsStruct) HandleOfficialJobsFromJSONFile(client *ethclient.Client, collection bindings.StructsCollection, dataString string, commitParams *types.CommitParams) ([]bindings.StructsJob, []uint16) { +func (*UtilsStruct) HandleOfficialJobsFromJSONFile(collection bindings.StructsCollection, dataString string, commitParams *types.CommitParams) ([]bindings.StructsJob, []uint16) { var overrideJobs []bindings.StructsJob var overriddenJobIds []uint16 @@ -533,7 +453,7 @@ func (*UtilsStruct) HandleOfficialJobsFromJSONFile(client *ethclient.Client, col } // InitJobsCache initializes the jobs cache with data fetched from the blockchain -func InitJobsCache(client *ethclient.Client, jobsCache *cache.JobsCache) error { +func InitJobsCache(rpcParameters rpc.RPCParameters, jobsCache *cache.JobsCache) error { jobsCache.Mu.Lock() defer jobsCache.Mu.Unlock() @@ -542,12 +462,12 @@ func InitJobsCache(client *ethclient.Client, jobsCache *cache.JobsCache) error { delete(jobsCache.Jobs, k) } - numJobs, err := AssetManagerInterface.GetNumJobs(client) + numJobs, err := UtilsInterface.GetNumJobs(rpcParameters) if err != nil { return err } for i := 1; i <= int(numJobs); i++ { - job, err := UtilsInterface.GetActiveJob(client, uint16(i)) + job, err := UtilsInterface.GetActiveJob(rpcParameters, uint16(i)) if err != nil { return err } @@ -557,7 +477,7 @@ func InitJobsCache(client *ethclient.Client, jobsCache *cache.JobsCache) error { } // InitCollectionsCache initializes the collections cache with data fetched from the blockchain -func InitCollectionsCache(client *ethclient.Client, collectionsCache *cache.CollectionsCache) error { +func InitCollectionsCache(rpcParameters rpc.RPCParameters, collectionsCache *cache.CollectionsCache) error { collectionsCache.Mu.Lock() defer collectionsCache.Mu.Unlock() @@ -566,12 +486,12 @@ func InitCollectionsCache(client *ethclient.Client, collectionsCache *cache.Coll delete(collectionsCache.Collections, k) } - numCollections, err := AssetManagerInterface.GetNumCollections(client) + numCollections, err := UtilsInterface.GetNumCollections(rpcParameters) if err != nil { return err } for i := 1; i <= int(numCollections); i++ { - collection, err := AssetManagerInterface.GetCollection(client, uint16(i)) + collection, err := UtilsInterface.GetCollection(rpcParameters, uint16(i)) if err != nil { return err } diff --git a/utils/asset_test.go b/utils/asset_test.go index cf4dfa740..65c25e198 100644 --- a/utils/asset_test.go +++ b/utils/asset_test.go @@ -1,6 +1,7 @@ package utils import ( + "context" "errors" "fmt" "io/fs" @@ -13,6 +14,7 @@ import ( "razor/path" pathMocks "razor/path/mocks" "razor/pkg/bindings" + "razor/rpc" "razor/utils/mocks" "reflect" "regexp" @@ -25,9 +27,19 @@ import ( "github.com/stretchr/testify/mock" ) +var rpcManager = rpc.RPCManager{ + BestEndpoint: &rpc.RPCEndpoint{ + Client: ðclient.Client{}, + }, +} + +var rpcParameters = rpc.RPCParameters{ + Ctx: context.Background(), + RPCManager: &rpcManager, +} + func TestAggregate(t *testing.T) { var ( - client *ethclient.Client previousEpoch uint32 fileInfo fs.FileInfo ) @@ -199,14 +211,14 @@ func TestAggregate(t *testing.T) { utils := StartRazor(optionsPackageStruct) utilsMock.On("GetDataToCommitFromJobs", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.dataToCommit, tt.args.weight, tt.args.dataToCommitErr) - utilsMock.On("FetchPreviousValue", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint16")).Return(tt.args.prevCommitmentData, tt.args.prevCommitmentDataErr) + utilsMock.On("FetchPreviousValue", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.prevCommitmentData, tt.args.prevCommitmentDataErr) pathUtilsMock.On("GetJobFilePath").Return(tt.args.assetFilePath, tt.args.assetFilePathErr) osUtilsMock.On("Stat", mock.Anything).Return(fileInfo, tt.args.statErr) osUtilsMock.On("Open", mock.Anything).Return(tt.args.jsonFile, tt.args.jsonFileErr) ioMock.On("ReadAll", mock.Anything).Return(tt.args.fileData, tt.args.fileDataErr) - utilsMock.On("HandleOfficialJobsFromJSONFile", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.overrrideJobs, tt.args.overrideJobIds) + utilsMock.On("HandleOfficialJobsFromJSONFile", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.overrrideJobs, tt.args.overrideJobIds) - got, err := utils.Aggregate(client, previousEpoch, tt.args.collection, commitParams) + got, err := utils.Aggregate(rpcParameters, previousEpoch, tt.args.collection, commitParams) if (err != nil) != tt.wantErr { t.Errorf("Aggregate() error = %v, wantErr %v", err, tt.wantErr) @@ -220,7 +232,6 @@ func TestAggregate(t *testing.T) { } func TestGetActiveCollectionIds(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts type args struct { @@ -267,7 +278,7 @@ func TestGetActiveCollectionIds(t *testing.T) { assetManagerMock.On("GetActiveCollections", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.activeAssetIds, tt.args.activeAssetIdsErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetActiveCollectionIds(client) + got, err := utils.GetActiveCollectionIds(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetActiveCollections() error = %v, wantErr %v", err, tt.wantErr) return @@ -347,7 +358,6 @@ func TestGetActiveCollection(t *testing.T) { } func TestGetActiveJob(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts var jobId uint16 @@ -400,7 +410,7 @@ func TestGetActiveJob(t *testing.T) { assetManagerMock.On("Jobs", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint16")).Return(tt.args.job, tt.args.jobErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetActiveJob(client, jobId) + got, err := utils.GetActiveJob(rpcParameters, jobId) if (err != nil) != tt.wantErr { t.Errorf("GetActiveJob() error = %v, wantErr %v", err, tt.wantErr) return @@ -413,7 +423,6 @@ func TestGetActiveJob(t *testing.T) { } func TestGetCollection(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts var collectionId uint16 @@ -461,7 +470,7 @@ func TestGetCollection(t *testing.T) { assetManagerMock.On("GetCollection", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint16")).Return(tt.args.asset, tt.args.assetErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetCollection(client, collectionId) + got, err := utils.GetCollection(rpcParameters, collectionId) if (err != nil) != tt.wantErr { t.Errorf("GetCollection() error = %v, wantErr %v", err, tt.wantErr) return @@ -474,8 +483,6 @@ func TestGetCollection(t *testing.T) { } func TestGetAllCollections(t *testing.T) { - var client *ethclient.Client - collectionListArray := []bindings.StructsCollection{ { Active: true, @@ -543,10 +550,10 @@ func TestGetAllCollections(t *testing.T) { } utils := StartRazor(optionsPackageStruct) - utilsMock.On("GetNumCollections", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.numAssets, tt.args.numAssetsErr) - assetMock.On("GetCollection", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint16")).Return(tt.args.collection, tt.args.collectionErr) + utilsMock.On("GetNumCollections", mock.Anything).Return(tt.args.numAssets, tt.args.numAssetsErr) + utilsMock.On("GetCollection", mock.Anything, mock.AnythingOfType("uint16")).Return(tt.args.collection, tt.args.collectionErr) - got, err := utils.GetAllCollections(client) + got, err := utils.GetAllCollections(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetAllCollections() error = %v, wantErr %v", err, tt.wantErr) return @@ -802,8 +809,6 @@ func TestGetDataToCommitFromJob(t *testing.T) { } func TestGetJobs(t *testing.T) { - var client *ethclient.Client - jobsArray := []bindings.StructsJob{ {Id: 1, SelectorType: 1, Weight: 100, Power: 2, Name: "ethusd_gemini", Selector: "last", @@ -812,10 +817,9 @@ func TestGetJobs(t *testing.T) { } type args struct { - numJobs uint16 - numJobsErr error - assetType uint8 - //assetTypeErr error + numJobs uint16 + numJobsErr error + assetType uint8 activeJob bindings.StructsJob activeJobErr error } @@ -867,10 +871,10 @@ func TestGetJobs(t *testing.T) { } utils := StartRazor(optionsPackageStruct) - assetMock.On("GetNumJobs", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.numJobs, tt.args.numJobsErr) - utilsMock.On("GetActiveJob", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint16")).Return(tt.args.activeJob, tt.args.activeJobErr) + utilsMock.On("GetNumJobs", mock.Anything).Return(tt.args.numJobs, tt.args.numJobsErr) + utilsMock.On("GetActiveJob", mock.Anything, mock.Anything).Return(tt.args.activeJob, tt.args.activeJobErr) - got, err := utils.GetJobs(client) + got, err := utils.GetJobs(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetJobs() error = %v, wantErr %v", err, tt.wantErr) return @@ -883,7 +887,6 @@ func TestGetJobs(t *testing.T) { } func TestGetNumActiveCollections(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts type args struct { @@ -930,7 +933,7 @@ func TestGetNumActiveCollections(t *testing.T) { assetManagerMock.On("GetNumActiveCollections", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.numOfActiveAssets, tt.args.numOfActiveAssetsErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetNumActiveCollections(client) + got, err := utils.GetNumActiveCollections(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetNumActiveCollections() error = %v, wantErr %v", err, tt.wantErr) return @@ -943,7 +946,6 @@ func TestGetNumActiveCollections(t *testing.T) { } func TestGetNumCollections(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts type args struct { @@ -987,10 +989,10 @@ func TestGetNumCollections(t *testing.T) { utils := StartRazor(optionsPackageStruct) utilsMock.On("GetOptions").Return(callOpts) - assetManagerMock.On("GetNumCollections", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.numOfAssets, tt.args.numOfAssetsErr) + assetManagerMock.On("GetNumCollections", mock.Anything, mock.Anything).Return(tt.args.numOfAssets, tt.args.numOfAssetsErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetNumCollections(client) + got, err := utils.GetNumCollections(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetNumCollections() error = %v, wantErr %v", err, tt.wantErr) return @@ -1114,7 +1116,6 @@ func TestConvertCustomJobToStructJob(t *testing.T) { } func TestHandleOfficialJobsFromJSONFile(t *testing.T) { - var client *ethclient.Client ethCollection := bindings.StructsCollection{ Active: true, Id: 7, Power: 2, AggregationMethod: 2, JobIDs: []uint16{1}, Name: "ethCollection", @@ -1225,7 +1226,7 @@ func TestHandleOfficialJobsFromJSONFile(t *testing.T) { utils := &UtilsStruct{} - gotJobs, gotOverrideJobIds := utils.HandleOfficialJobsFromJSONFile(client, tt.args.collection, tt.args.dataString, commitParams) + gotJobs, gotOverrideJobIds := utils.HandleOfficialJobsFromJSONFile(tt.args.collection, tt.args.dataString, commitParams) if !reflect.DeepEqual(gotJobs, tt.want) { t.Errorf("HandleOfficialJobsFromJSONFile() gotJobs = %v, want %v", gotJobs, tt.want) } @@ -1276,7 +1277,6 @@ var jsonDataString = `{ func TestGetAggregatedDataOfCollection(t *testing.T) { var ( - client *ethclient.Client collectionId uint16 epoch uint32 ) @@ -1328,9 +1328,9 @@ func TestGetAggregatedDataOfCollection(t *testing.T) { utils := StartRazor(optionsPackageStruct) utilsMock.On("GetActiveCollection", mock.Anything, mock.Anything).Return(tt.args.activeCollection, tt.args.activeCollectionErr) - utilsMock.On("Aggregate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.collectionData, tt.args.aggregationErr) + utilsMock.On("Aggregate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.collectionData, tt.args.aggregationErr) - got, err := utils.GetAggregatedDataOfCollection(client, collectionId, epoch, &types.CommitParams{HttpClient: &http.Client{}}) + got, err := utils.GetAggregatedDataOfCollection(rpcParameters, collectionId, epoch, &types.CommitParams{HttpClient: &http.Client{}}) if (err != nil) != tt.wantErr { t.Errorf("GetAggregatedDataOfCollection() error = %v, wantErr %v", err, tt.wantErr) return @@ -1344,7 +1344,6 @@ func TestGetAggregatedDataOfCollection(t *testing.T) { func TestGetAssignedCollections(t *testing.T) { var ( - client *ethclient.Client numActiveCollections uint16 seed []byte ) @@ -1391,7 +1390,7 @@ func TestGetAssignedCollections(t *testing.T) { utilsMock.On("ToAssign", mock.Anything).Return(tt.args.toAssign, tt.args.toAssignErr) utilsMock.On("Prng", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.assigned) - got, got1, err := utils.GetAssignedCollections(client, numActiveCollections, seed) + got, got1, err := utils.GetAssignedCollections(rpcParameters, numActiveCollections, seed) if (err != nil) != tt.wantErr { t.Errorf("GetAssignedCollections() error = %v, wantErr %v", err, tt.wantErr) return @@ -1407,10 +1406,7 @@ func TestGetAssignedCollections(t *testing.T) { } func TestGetLeafIdOfACollection(t *testing.T) { - var ( - client *ethclient.Client - collectionId uint16 - ) + var collectionId uint16 type args struct { leafId uint16 leafIdErr error @@ -1451,7 +1447,7 @@ func TestGetLeafIdOfACollection(t *testing.T) { assetManagerMock.On("GetLeafIdOfACollection", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.leafId, tt.args.leafIdErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetLeafIdOfACollection(client, collectionId) + got, err := utils.GetLeafIdOfACollection(rpcParameters, collectionId) if (err != nil) != tt.wantErr { t.Errorf("GetLeafIdOfACollection() error = %v, wantErr %v", err, tt.wantErr) return @@ -1464,10 +1460,7 @@ func TestGetLeafIdOfACollection(t *testing.T) { } func TestGetCollectionIdFromIndex(t *testing.T) { - var ( - client *ethclient.Client - medianIndex uint16 - ) + var medianIndex uint16 type args struct { collectionId uint16 collectionIdErr error @@ -1508,7 +1501,7 @@ func TestGetCollectionIdFromIndex(t *testing.T) { assetManagerMock.On("GetCollectionIdFromIndex", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.collectionId, tt.args.collectionIdErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetCollectionIdFromIndex(client, medianIndex) + got, err := utils.GetCollectionIdFromIndex(rpcParameters, medianIndex) if (err != nil) != tt.wantErr { t.Errorf("GetCollectionIdFromIndex() error = %v, wantErr %v", err, tt.wantErr) return @@ -1521,10 +1514,7 @@ func TestGetCollectionIdFromIndex(t *testing.T) { } func TestGetCollectionIdFromLeafId(t *testing.T) { - var ( - client *ethclient.Client - leafId uint16 - ) + var leafId uint16 type args struct { collectionId uint16 collectionIdErr error @@ -1562,10 +1552,10 @@ func TestGetCollectionIdFromLeafId(t *testing.T) { AssetManagerInterface: assetManagerMock, } utils := StartRazor(optionsPackageStruct) - assetManagerMock.On("GetCollectionIdFromLeafId", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.collectionId, tt.args.collectionIdErr) + assetManagerMock.On("GetCollectionIdFromLeafId", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.collectionId, tt.args.collectionIdErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetCollectionIdFromLeafId(client, leafId) + got, err := utils.GetCollectionIdFromLeafId(rpcParameters, leafId) if (err != nil) != tt.wantErr { t.Errorf("GetCollectionIdFromLeafId() error = %v, wantErr %v", err, tt.wantErr) return diff --git a/utils/batch.go b/utils/batch.go index a7a5bfdbc..e44ec0450 100644 --- a/utils/batch.go +++ b/utils/batch.go @@ -7,22 +7,22 @@ import ( "github.com/avast/retry-go" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" - "github.com/ethereum/go-ethereum/rpc" + RPC "github.com/ethereum/go-ethereum/rpc" "razor/core" + "razor/rpc" ) //Each batch call may require multiple arguments therefore defining args as [][]interface{} // BatchCall performs a batch call to the Ethereum client, using the provided contract ABI, address, method name, and arguments. -func (c ClientStruct) BatchCall(client *ethclient.Client, contractABI *abi.ABI, contractAddress, methodName string, args [][]interface{}) ([][]interface{}, error) { +func (c ClientStruct) BatchCall(rpcParameters rpc.RPCParameters, contractABI *abi.ABI, contractAddress, methodName string, args [][]interface{}) ([][]interface{}, error) { calls, err := ClientInterface.CreateBatchCalls(contractABI, contractAddress, methodName, args) if err != nil { log.Errorf("Error in creating batch calls: %v", err) return nil, err } - err = performBatchCallWithRetry(client, calls) + err = performBatchCallWithRetry(rpcParameters, calls) if err != nil { log.Errorf("Error in performing batch call: %v", err) return nil, err @@ -38,8 +38,8 @@ func (c ClientStruct) BatchCall(client *ethclient.Client, contractABI *abi.ABI, } // CreateBatchCalls creates a slice of rpc.BatchElem, each representing an Ethereum call, using the provided ABI, contract address, method name, and arguments. -func (c ClientStruct) CreateBatchCalls(contractABI *abi.ABI, contractAddress, methodName string, args [][]interface{}) ([]rpc.BatchElem, error) { - var calls []rpc.BatchElem +func (c ClientStruct) CreateBatchCalls(contractABI *abi.ABI, contractAddress, methodName string, args [][]interface{}) ([]RPC.BatchElem, error) { + var calls []RPC.BatchElem for _, arg := range args { data, err := contractABI.Pack(methodName, arg...) @@ -48,7 +48,7 @@ func (c ClientStruct) CreateBatchCalls(contractABI *abi.ABI, contractAddress, me return nil, err } - calls = append(calls, rpc.BatchElem{ + calls = append(calls, RPC.BatchElem{ Method: "eth_call", Args: []interface{}{ map[string]interface{}{ @@ -63,8 +63,13 @@ func (c ClientStruct) CreateBatchCalls(contractABI *abi.ABI, contractAddress, me return calls, nil } -func (c ClientStruct) PerformBatchCall(client *ethclient.Client, calls []rpc.BatchElem) error { - err := client.Client().BatchCallContext(context.Background(), calls) +func (c ClientStruct) PerformBatchCall(rpcParameters rpc.RPCParameters, calls []RPC.BatchElem) error { + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + return err + } + + err = client.Client().BatchCallContext(context.Background(), calls) if err != nil { return err } @@ -72,9 +77,9 @@ func (c ClientStruct) PerformBatchCall(client *ethclient.Client, calls []rpc.Bat } // performBatchCallWithRetry performs the batch call to the Ethereum client with retry logic. -func performBatchCallWithRetry(client *ethclient.Client, calls []rpc.BatchElem) error { +func performBatchCallWithRetry(rpcParameters rpc.RPCParameters, calls []RPC.BatchElem) error { err := retry.Do(func() error { - err := ClientInterface.PerformBatchCall(client, calls) + err := ClientInterface.PerformBatchCall(rpcParameters, calls) if err != nil { log.Errorf("Error in performing batch call, retrying: %v", err) return err @@ -97,7 +102,7 @@ func performBatchCallWithRetry(client *ethclient.Client, calls []rpc.BatchElem) } // processBatchResults processes the results of the batch call, unpacking the data using the provided ABI and method name. -func processBatchResults(contractABI *abi.ABI, methodName string, calls []rpc.BatchElem) ([][]interface{}, error) { +func processBatchResults(contractABI *abi.ABI, methodName string, calls []RPC.BatchElem) ([][]interface{}, error) { var results [][]interface{} for _, call := range calls { diff --git a/utils/batch_test.go b/utils/batch_test.go index 00cdbc40b..cfcd48637 100644 --- a/utils/batch_test.go +++ b/utils/batch_test.go @@ -3,7 +3,6 @@ package utils import ( "errors" "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" "math/big" @@ -16,7 +15,6 @@ import ( func TestBatchCall(t *testing.T) { //Testing Batch call scenario for getting StakeSnapshot - var client *ethclient.Client voteManagerABI, _ := abi.JSON(strings.NewReader(bindings.VoteManagerMetaData.ABI)) stakeManagerABI, _ := abi.JSON(strings.NewReader(bindings.StakeManagerMetaData.ABI)) @@ -185,7 +183,7 @@ func TestBatchCall(t *testing.T) { clientMock.On("PerformBatchCall", mock.Anything, mock.Anything).Return(tt.args.performBatchCallErr) c := ClientStruct{} - gotResults, err := c.BatchCall(client, tt.args.contractABI, tt.args.contractAddress, tt.args.methodName, arguments) + gotResults, err := c.BatchCall(rpcParameters, tt.args.contractABI, tt.args.contractAddress, tt.args.methodName, arguments) if (err != nil) != tt.wantErr { t.Errorf("BatchCall() error = %v, but wantErr bool is %v", err, tt.wantErr) return diff --git a/utils/block.go b/utils/block.go index 80f303421..4aa739b6d 100644 --- a/utils/block.go +++ b/utils/block.go @@ -2,8 +2,11 @@ package utils import ( "errors" + "github.com/ethereum/go-ethereum/common" "math/big" + Types "razor/core/types" "razor/pkg/bindings" + "razor/rpc" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/ethclient" @@ -13,24 +16,24 @@ func (*UtilsStruct) GetBlockManagerWithOpts(client *ethclient.Client) (*bindings return UtilsInterface.GetBlockManager(client), UtilsInterface.GetOptions() } -func (*UtilsStruct) GetNumberOfProposedBlocks(client *ethclient.Client, epoch uint32) (uint8, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(BlockManagerInterface, "GetNumProposedBlocks", client, epoch) +func (*UtilsStruct) GetNumberOfProposedBlocks(rpcParameters rpc.RPCParameters, epoch uint32) (uint8, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, BlockManagerInterface, "GetNumProposedBlocks", epoch) if err != nil { return 0, err } return returnedValues[0].Interface().(uint8), nil } -func (*UtilsStruct) GetProposedBlock(client *ethclient.Client, epoch uint32, proposedBlockId uint32) (bindings.StructsBlock, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(BlockManagerInterface, "GetProposedBlock", client, epoch, proposedBlockId) +func (*UtilsStruct) GetProposedBlock(rpcParameters rpc.RPCParameters, epoch uint32, proposedBlockId uint32) (bindings.StructsBlock, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, BlockManagerInterface, "GetProposedBlock", epoch, proposedBlockId) if err != nil { return bindings.StructsBlock{}, err } return returnedValues[0].Interface().(bindings.StructsBlock), nil } -func (*UtilsStruct) FetchPreviousValue(client *ethclient.Client, epoch uint32, assetId uint16) (*big.Int, error) { - block, err := UtilsInterface.GetBlock(client, epoch) +func (*UtilsStruct) FetchPreviousValue(rpcParameters rpc.RPCParameters, epoch uint32, assetId uint16) (*big.Int, error) { + block, err := UtilsInterface.GetBlock(rpcParameters, epoch) if err != nil { return big.NewInt(0), err } @@ -40,24 +43,24 @@ func (*UtilsStruct) FetchPreviousValue(client *ethclient.Client, epoch uint32, a return block.Medians[assetId-1], nil } -func (*UtilsStruct) GetBlock(client *ethclient.Client, epoch uint32) (bindings.StructsBlock, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(BlockManagerInterface, "GetBlock", client, epoch) +func (*UtilsStruct) GetBlock(rpcParameters rpc.RPCParameters, epoch uint32) (bindings.StructsBlock, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, BlockManagerInterface, "GetBlock", epoch) if err != nil { return bindings.StructsBlock{}, err } return returnedValues[0].Interface().(bindings.StructsBlock), nil } -func (*UtilsStruct) GetMinStakeAmount(client *ethclient.Client) (*big.Int, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(BlockManagerInterface, "MinStake", client) +func (*UtilsStruct) GetMinStakeAmount(rpcParameters rpc.RPCParameters) (*big.Int, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, BlockManagerInterface, "MinStake") if err != nil { return nil, err } return returnedValues[0].Interface().(*big.Int), nil } -func (*UtilsStruct) GetStateBuffer(client *ethclient.Client) (uint64, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(BlockManagerInterface, "StateBuffer", client) +func (*UtilsStruct) GetStateBuffer(rpcParameters rpc.RPCParameters) (uint64, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, BlockManagerInterface, "StateBuffer") if err != nil { return 0, err } @@ -65,31 +68,31 @@ func (*UtilsStruct) GetStateBuffer(client *ethclient.Client) (uint64, error) { return uint64(stateBufferUint8), nil } -func (*UtilsStruct) GetMaxAltBlocks(client *ethclient.Client) (uint8, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(BlockManagerInterface, "MaxAltBlocks", client) +func (*UtilsStruct) GetMaxAltBlocks(rpcParameters rpc.RPCParameters) (uint8, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, BlockManagerInterface, "MaxAltBlocks") if err != nil { return 0, err } return returnedValues[0].Interface().(uint8), nil } -func (*UtilsStruct) GetSortedProposedBlockId(client *ethclient.Client, epoch uint32, index *big.Int) (uint32, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(BlockManagerInterface, "SortedProposedBlockIds", client, epoch, index) +func (*UtilsStruct) GetSortedProposedBlockId(rpcParameters rpc.RPCParameters, epoch uint32, index *big.Int) (uint32, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, BlockManagerInterface, "SortedProposedBlockIds", epoch, index) if err != nil { return 0, err } return returnedValues[0].Interface().(uint32), nil } -func (*UtilsStruct) GetSortedProposedBlockIds(client *ethclient.Client, epoch uint32) ([]uint32, error) { - numberOfProposedBlocks, err := UtilsInterface.GetNumberOfProposedBlocks(client, epoch) +func (*UtilsStruct) GetSortedProposedBlockIds(rpcParameters rpc.RPCParameters, epoch uint32) ([]uint32, error) { + numberOfProposedBlocks, err := UtilsInterface.GetNumberOfProposedBlocks(rpcParameters, epoch) if err != nil { log.Error(err) return nil, err } var sortedProposedBlockIds []uint32 for i := 0; i < int(numberOfProposedBlocks); i++ { - id, err := UtilsInterface.GetSortedProposedBlockId(client, epoch, big.NewInt(int64(i))) + id, err := UtilsInterface.GetSortedProposedBlockId(rpcParameters, epoch, big.NewInt(int64(i))) if err != nil { log.Error(err) return nil, err @@ -99,18 +102,34 @@ func (*UtilsStruct) GetSortedProposedBlockIds(client *ethclient.Client, epoch ui return sortedProposedBlockIds, nil } -func (*UtilsStruct) GetBlockIndexToBeConfirmed(client *ethclient.Client) (int8, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(BlockManagerInterface, "GetBlockIndexToBeConfirmed", client) +func (*UtilsStruct) GetBlockIndexToBeConfirmed(rpcParameters rpc.RPCParameters) (int8, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, BlockManagerInterface, "GetBlockIndexToBeConfirmed") if err != nil { return 0, err } return returnedValues[0].Interface().(int8), nil } -func (*UtilsStruct) GetEpochLastProposed(client *ethclient.Client, stakerId uint32) (uint32, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(BlockManagerInterface, "GetEpochLastProposed", client, stakerId) +func (*UtilsStruct) GetEpochLastProposed(rpcParameters rpc.RPCParameters, stakerId uint32) (uint32, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, BlockManagerInterface, "GetEpochLastProposed", stakerId) if err != nil { return 0, err } return returnedValues[0].Interface().(uint32), nil } + +func (*UtilsStruct) GetConfirmedBlocks(rpcParameters rpc.RPCParameters, epoch uint32) (Types.ConfirmedBlock, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, BlockManagerInterface, "GetConfirmedBlocks", epoch) + if err != nil { + return Types.ConfirmedBlock{}, err + } + return returnedValues[0].Interface().(Types.ConfirmedBlock), nil +} + +func (*UtilsStruct) Disputes(rpcParameters rpc.RPCParameters, epoch uint32, address common.Address) (Types.DisputesStruct, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, BlockManagerInterface, "Disputes", epoch, address) + if err != nil { + return Types.DisputesStruct{}, err + } + return returnedValues[0].Interface().(Types.DisputesStruct), nil +} diff --git a/utils/block_test.go b/utils/block_test.go index 54d8ec738..53fba59ac 100644 --- a/utils/block_test.go +++ b/utils/block_test.go @@ -2,7 +2,9 @@ package utils import ( "errors" + "github.com/ethereum/go-ethereum/common" "math/big" + "razor/core/types" "razor/pkg/bindings" "razor/utils/mocks" "reflect" @@ -15,7 +17,6 @@ import ( ) func TestFetchPreviousValue(t *testing.T) { - var client *ethclient.Client var epoch uint32 type args struct { @@ -63,10 +64,10 @@ func TestFetchPreviousValue(t *testing.T) { } utils := StartRazor(optionsPackageStruct) - utilsMock.On("GetBlock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.block, tt.args.blockErr) + utilsMock.On("GetBlock", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.block, tt.args.blockErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.FetchPreviousValue(client, epoch, tt.args.assetId) + got, err := utils.FetchPreviousValue(rpcParameters, epoch, tt.args.assetId) if (err != nil) != tt.wantErr { t.Errorf("FetchPreviousValue() error = %v, wantErr %v", err, tt.wantErr) return @@ -79,7 +80,6 @@ func TestFetchPreviousValue(t *testing.T) { } func TestGetMaxAltBlocks(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts type args struct { @@ -126,7 +126,7 @@ func TestGetMaxAltBlocks(t *testing.T) { blockManagerMock.On("MaxAltBlocks", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.maxAltBlocks, tt.args.maxAltBlocksErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetMaxAltBlocks(client) + got, err := utils.GetMaxAltBlocks(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("MaxAltBlocks() error = %v, wantErr %v", err, tt.wantErr) return @@ -139,7 +139,6 @@ func TestGetMaxAltBlocks(t *testing.T) { } func TestGetMinStakeAmount(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts type args struct { @@ -186,7 +185,7 @@ func TestGetMinStakeAmount(t *testing.T) { blockManagerMock.On("MinStake", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.minStake, tt.args.minStakeErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetMinStakeAmount(client) + got, err := utils.GetMinStakeAmount(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetMinStakeAmount() error = %v, wantErr %v", err, tt.wantErr) return @@ -199,7 +198,6 @@ func TestGetMinStakeAmount(t *testing.T) { } func TestGetNumberOfProposedBlocks(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts var epoch uint32 @@ -247,7 +245,7 @@ func TestGetNumberOfProposedBlocks(t *testing.T) { blockManagerMock.On("GetNumProposedBlocks", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.numOfProposedBlocks, tt.args.numOfProposedBlocksErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetNumberOfProposedBlocks(client, epoch) + got, err := utils.GetNumberOfProposedBlocks(rpcParameters, epoch) if (err != nil) != tt.wantErr { t.Errorf("GetNumberOfProposedBlocks() error = %v, wantErr %v", err, tt.wantErr) return @@ -260,7 +258,6 @@ func TestGetNumberOfProposedBlocks(t *testing.T) { } func TestGetProposedBlock(t *testing.T) { - var client *ethclient.Client var epoch uint32 var proposedBlockId uint32 var callOpts bind.CallOpts @@ -313,7 +310,7 @@ func TestGetProposedBlock(t *testing.T) { blockManagerMock.On("GetProposedBlock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(tt.args.block, tt.args.blockErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetProposedBlock(client, epoch, proposedBlockId) + got, err := utils.GetProposedBlock(rpcParameters, epoch, proposedBlockId) if (err != nil) != tt.wantErr { t.Errorf("GetProposedBlock() error = %v, wantErr %v", err, tt.wantErr) return @@ -326,7 +323,6 @@ func TestGetProposedBlock(t *testing.T) { } func TestGetSortedProposedBlockId(t *testing.T) { - var client *ethclient.Client var epoch uint32 var index *big.Int var callOpts bind.CallOpts @@ -375,7 +371,7 @@ func TestGetSortedProposedBlockId(t *testing.T) { blockManagerMock.On("SortedProposedBlockIds", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("*big.Int")).Return(tt.args.sortedProposedBlockId, tt.args.sortedProposedBlockIdErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetSortedProposedBlockId(client, epoch, index) + got, err := utils.GetSortedProposedBlockId(rpcParameters, epoch, index) if (err != nil) != tt.wantErr { t.Errorf("GetSortedProposedBlockId() error = %v, wantErr %v", err, tt.wantErr) return @@ -388,7 +384,6 @@ func TestGetSortedProposedBlockId(t *testing.T) { } func TestGetSortedProposedBlockIds(t *testing.T) { - var client *ethclient.Client var epoch uint32 type args struct { @@ -439,10 +434,10 @@ func TestGetSortedProposedBlockIds(t *testing.T) { } utils := StartRazor(optionsPackageStruct) - utilsMock.On("GetNumberOfProposedBlocks", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.numOfProposedBlocks, tt.args.numOfProposedBlocksErr) - utilsMock.On("GetSortedProposedBlockId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("*big.Int")).Return(tt.args.sortedProposedBlockId, tt.args.sortedProposedBlockIdErr) + utilsMock.On("GetNumberOfProposedBlocks", mock.Anything, mock.Anything).Return(tt.args.numOfProposedBlocks, tt.args.numOfProposedBlocksErr) + utilsMock.On("GetSortedProposedBlockId", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.args.sortedProposedBlockId, tt.args.sortedProposedBlockIdErr) - got, err := utils.GetSortedProposedBlockIds(client, epoch) + got, err := utils.GetSortedProposedBlockIds(rpcParameters, epoch) if (err != nil) != tt.wantErr { t.Errorf("GetSortedProposedBlockIds() error = %v, wantErr %v", err, tt.wantErr) return @@ -480,10 +475,7 @@ func TestGetBlockManagerWithOpts(t *testing.T) { } func TestGetBlock(t *testing.T) { - var ( - client *ethclient.Client - epoch uint32 - ) + var epoch uint32 type args struct { block bindings.StructsBlock blockErr error @@ -525,7 +517,7 @@ func TestGetBlock(t *testing.T) { blockManagerMock.On("GetBlock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.block, tt.args.blockErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetBlock(client, epoch) + got, err := utils.GetBlock(rpcParameters, epoch) if (err != nil) != tt.wantErr { t.Errorf("GetBlock() error = %v, wantErr %v", err, tt.wantErr) return @@ -538,7 +530,6 @@ func TestGetBlock(t *testing.T) { } func TestGetBlockIndexToBeConfirmed(t *testing.T) { - var client *ethclient.Client type args struct { blockIndex int8 blockIndexErr error @@ -580,7 +571,7 @@ func TestGetBlockIndexToBeConfirmed(t *testing.T) { blockManagerMock.On("GetBlockIndexToBeConfirmed", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.blockIndex, tt.args.blockIndexErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetBlockIndexToBeConfirmed(client) + got, err := utils.GetBlockIndexToBeConfirmed(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetBlockIndexToBeConfirmed() error = %v, wantErr %v", err, tt.wantErr) return @@ -593,7 +584,6 @@ func TestGetBlockIndexToBeConfirmed(t *testing.T) { } func TestGetStateBuffer(t *testing.T) { - var client *ethclient.Client type args struct { stateBuffer uint8 stateBufferErr error @@ -635,7 +625,7 @@ func TestGetStateBuffer(t *testing.T) { blockManagerMock.On("StateBuffer", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.stateBuffer, tt.args.stateBufferErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetStateBuffer(client) + got, err := utils.GetStateBuffer(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetStateBuffer() error = %v, wantErr %v", err, tt.wantErr) return @@ -648,7 +638,6 @@ func TestGetStateBuffer(t *testing.T) { } func TestGetEpochLastProposed(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts var stakerId uint32 @@ -696,7 +685,7 @@ func TestGetEpochLastProposed(t *testing.T) { blockManagerMock.On("GetEpochLastProposed", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.epochLastProposed, tt.args.epochLastProposedErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetEpochLastProposed(client, stakerId) + got, err := utils.GetEpochLastProposed(rpcParameters, stakerId) if (err != nil) != tt.wantErr { t.Errorf("GetEpochLastProposed() error = %v, wantErr %v", err, tt.wantErr) return @@ -707,3 +696,132 @@ func TestGetEpochLastProposed(t *testing.T) { }) } } + +func TestGetConfirmedBlocks(t *testing.T) { + var callOpts bind.CallOpts + var epoch uint32 + + type args struct { + confirmedBlock types.ConfirmedBlock + confirmedBlockErr error + } + tests := []struct { + name string + args args + want types.ConfirmedBlock + wantErr bool + }{ + { + name: "Test 1: When GetConfirmedBlocks() executes successfully", + args: args{ + confirmedBlock: types.ConfirmedBlock{ + ProposerId: 1, + }, + }, + want: types.ConfirmedBlock{ + ProposerId: 1, + }, + wantErr: false, + }, + { + name: "Test 2: When there is an error in getting confirmedBlock", + args: args{ + confirmedBlockErr: errors.New("confirmedBlock error"), + }, + want: types.ConfirmedBlock{}, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + retryMock := new(mocks.RetryUtils) + utilsMock := new(mocks.Utils) + blockManagerMock := new(mocks.BlockManagerUtils) + + optionsPackageStruct := OptionsPackageStruct{ + RetryInterface: retryMock, + UtilsInterface: utilsMock, + BlockManagerInterface: blockManagerMock, + } + utils := StartRazor(optionsPackageStruct) + + utilsMock.On("GetOptions").Return(callOpts) + blockManagerMock.On("GetConfirmedBlocks", mock.Anything, mock.Anything).Return(tt.args.confirmedBlock, tt.args.confirmedBlockErr) + retryMock.On("RetryAttempts", mock.Anything).Return(retry.Attempts(1)) + + got, err := utils.GetConfirmedBlocks(rpcParameters, epoch) + if (err != nil) != tt.wantErr { + t.Errorf("GetConfirmedBlocks() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("GetConfirmedBlocks() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDisputes(t *testing.T) { + var callOpts bind.CallOpts + var epoch uint32 + var address common.Address + + type args struct { + disputes types.DisputesStruct + disputesErr error + } + tests := []struct { + name string + args args + want types.DisputesStruct + wantErr bool + }{ + { + name: "Test 1: When Disputes() executes successfully", + args: args{ + disputes: types.DisputesStruct{ + LeafId: 1, + }, + }, + want: types.DisputesStruct{ + LeafId: 1, + }, + wantErr: false, + }, + { + name: "Test 2: When there is an error in getting disputes", + args: args{ + disputesErr: errors.New("disputes error"), + }, + want: types.DisputesStruct{}, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + retryMock := new(mocks.RetryUtils) + utilsMock := new(mocks.Utils) + blockManagerMock := new(mocks.BlockManagerUtils) + + optionsPackageStruct := OptionsPackageStruct{ + RetryInterface: retryMock, + UtilsInterface: utilsMock, + BlockManagerInterface: blockManagerMock, + } + utils := StartRazor(optionsPackageStruct) + + utilsMock.On("GetOptions").Return(callOpts) + blockManagerMock.On("Disputes", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.disputes, tt.args.disputesErr) + retryMock.On("RetryAttempts", mock.Anything).Return(retry.Attempts(1)) + + got, err := utils.Disputes(rpcParameters, epoch, address) + if (err != nil) != tt.wantErr { + t.Errorf("Disputes() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("Disputes() got = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/utils/client_methods.go b/utils/client_methods.go index e4b492501..7a7b1df4f 100644 --- a/utils/client_methods.go +++ b/utils/client_methods.go @@ -2,83 +2,65 @@ package utils import ( "context" - "github.com/avast/retry-go" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" "math/big" - "razor/core" + "razor/rpc" ) -func (*ClientStruct) GetNonceAtWithRetry(client *ethclient.Client, accountAddress common.Address) (uint64, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(ClientInterface, "NonceAt", client, context.Background(), accountAddress) +func (*ClientStruct) GetNonceAtWithRetry(rpcParameters rpc.RPCParameters, accountAddress common.Address) (uint64, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, ClientInterface, "NonceAt", context.Background(), accountAddress) if err != nil { return 0, err } return returnedValues[0].Interface().(uint64), nil } -func (*ClientStruct) GetLatestBlockWithRetry(client *ethclient.Client) (*types.Header, error) { +func (*ClientStruct) GetLatestBlockWithRetry(rpcParameters rpc.RPCParameters) (*types.Header, error) { var blockNumberArgument *big.Int - returnedValues, err := InvokeFunctionWithRetryAttempts(ClientInterface, "HeaderByNumber", client, context.Background(), blockNumberArgument) + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, ClientInterface, "HeaderByNumber", context.Background(), blockNumberArgument) if err != nil { return nil, err } return returnedValues[0].Interface().(*types.Header), nil } -func (*ClientStruct) SuggestGasPriceWithRetry(client *ethclient.Client) (*big.Int, error) { - var ( - gasPrice *big.Int - err error - ) - err = retry.Do( - func() error { - gasPrice, err = ClientInterface.SuggestGasPrice(client, context.Background()) - if err != nil { - log.Error("Error in fetching gas price.... Retrying") - return err - } - return nil - }, RetryInterface.RetryAttempts(core.MaxRetries)) +func (*ClientStruct) GetBlockByNumberWithRetry(rpcParameters rpc.RPCParameters, blockNumber *big.Int) (*types.Header, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, ClientInterface, "HeaderByNumber", context.Background(), blockNumber) if err != nil { return nil, err } - return gasPrice, nil + return returnedValues[0].Interface().(*types.Header), nil +} + +func (*ClientStruct) SuggestGasPriceWithRetry(rpcParameters rpc.RPCParameters) (*big.Int, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, ClientInterface, "SuggestGasPrice", context.Background()) + if err != nil { + return nil, err + } + return returnedValues[0].Interface().(*big.Int), nil } -func (*ClientStruct) EstimateGasWithRetry(client *ethclient.Client, message ethereum.CallMsg) (uint64, error) { - var ( - gasLimit uint64 - err error - ) - err = retry.Do( - func() error { - gasLimit, err = ClientInterface.EstimateGas(client, context.Background(), message) - if err != nil { - log.Error("Error in estimating gas limit.... Retrying") - return err - } - return nil - }, RetryInterface.RetryAttempts(core.MaxRetries)) +func (*ClientStruct) EstimateGasWithRetry(rpcParameters rpc.RPCParameters, message ethereum.CallMsg) (uint64, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, ClientInterface, "EstimateGas", context.Background(), message) if err != nil { return 0, err } - return gasLimit, nil + return returnedValues[0].Interface().(uint64), nil } -func (*ClientStruct) FilterLogsWithRetry(client *ethclient.Client, query ethereum.FilterQuery) ([]types.Log, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(ClientInterface, "FilterLogs", client, context.Background(), query) +func (*ClientStruct) FilterLogsWithRetry(rpcParameters rpc.RPCParameters, query ethereum.FilterQuery) ([]types.Log, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, ClientInterface, "FilterLogs", context.Background(), query) if err != nil { return nil, err } return returnedValues[0].Interface().([]types.Log), nil } -func (*ClientStruct) BalanceAtWithRetry(client *ethclient.Client, account common.Address) (*big.Int, error) { +func (*ClientStruct) BalanceAtWithRetry(rpcParameters rpc.RPCParameters, account common.Address) (*big.Int, error) { var blockNumberArgument *big.Int - returnedValues, err := InvokeFunctionWithRetryAttempts(ClientInterface, "BalanceAt", client, context.Background(), account, blockNumberArgument) + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, ClientInterface, "BalanceAt", context.Background(), account, blockNumberArgument) if err != nil { return nil, err } diff --git a/utils/client_methods_test.go b/utils/client_methods_test.go index ac879bb2d..af59cbb87 100644 --- a/utils/client_methods_test.go +++ b/utils/client_methods_test.go @@ -12,13 +12,10 @@ import ( "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/mock" ) func TestOptionUtilsStruct_SuggestGasPriceWithRetry(t *testing.T) { - var client *ethclient.Client - type args struct { gasPrice *big.Int gasPriceErr error @@ -62,7 +59,7 @@ func TestOptionUtilsStruct_SuggestGasPriceWithRetry(t *testing.T) { retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) clientUtils := ClientStruct{} - got, err := clientUtils.SuggestGasPriceWithRetry(client) + got, err := clientUtils.SuggestGasPriceWithRetry(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("SuggestGasPriceWithRetry() error = %v, wantErr %v", err, tt.wantErr) return @@ -75,7 +72,6 @@ func TestOptionUtilsStruct_SuggestGasPriceWithRetry(t *testing.T) { } func TestUtilsStruct_BalanceAtWithRetry(t *testing.T) { - var client *ethclient.Client var account common.Address type args struct { @@ -120,7 +116,7 @@ func TestUtilsStruct_BalanceAtWithRetry(t *testing.T) { retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) clientUtils := ClientStruct{} - got, err := clientUtils.BalanceAtWithRetry(client, account) + got, err := clientUtils.BalanceAtWithRetry(rpcParameters, account) if (err != nil) != tt.wantErr { t.Errorf("BalanceAtWithRetry() error = %v, wantErr %v", err, tt.wantErr) return @@ -133,7 +129,6 @@ func TestUtilsStruct_BalanceAtWithRetry(t *testing.T) { } func TestUtilsStruct_EstimateGasWithRetry(t *testing.T) { - var client *ethclient.Client var message ethereum.CallMsg type args struct { @@ -178,7 +173,7 @@ func TestUtilsStruct_EstimateGasWithRetry(t *testing.T) { retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) clientUtils := ClientStruct{} - got, err := clientUtils.EstimateGasWithRetry(client, message) + got, err := clientUtils.EstimateGasWithRetry(rpcParameters, message) if (err != nil) != tt.wantErr { t.Errorf("EstimateGasWithRetry() error = %v, wantErr %v", err, tt.wantErr) return @@ -191,7 +186,6 @@ func TestUtilsStruct_EstimateGasWithRetry(t *testing.T) { } func TestUtilsStruct_FilterLogsWithRetry(t *testing.T) { - var client *ethclient.Client var query ethereum.FilterQuery type args struct { @@ -235,7 +229,7 @@ func TestUtilsStruct_FilterLogsWithRetry(t *testing.T) { retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) clientUtils := ClientStruct{} - got, err := clientUtils.FilterLogsWithRetry(client, query) + got, err := clientUtils.FilterLogsWithRetry(rpcParameters, query) if (err != nil) != tt.wantErr { t.Errorf("FilterLogsWithRetry() error = %v, wantErr %v", err, tt.wantErr) return @@ -248,8 +242,6 @@ func TestUtilsStruct_FilterLogsWithRetry(t *testing.T) { } func TestUtilsStruct_GetLatestBlockWithRetry(t *testing.T) { - var client *ethclient.Client - type args struct { latestHeader *types.Header latestHeaderErr error @@ -291,7 +283,7 @@ func TestUtilsStruct_GetLatestBlockWithRetry(t *testing.T) { retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) clientUtils := ClientStruct{} - got, err := clientUtils.GetLatestBlockWithRetry(client) + got, err := clientUtils.GetLatestBlockWithRetry(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetLatestBlockWithRetry() error = %v, wantErr %v", err, tt.wantErr) return @@ -304,7 +296,6 @@ func TestUtilsStruct_GetLatestBlockWithRetry(t *testing.T) { } func TestUtilsStruct_GetNonceAtWithRetry(t *testing.T) { - var client *ethclient.Client var accountAddress common.Address type args struct { @@ -348,7 +339,7 @@ func TestUtilsStruct_GetNonceAtWithRetry(t *testing.T) { retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) clientUtils := ClientStruct{} - got, err := clientUtils.GetNonceAtWithRetry(client, accountAddress) + got, err := clientUtils.GetNonceAtWithRetry(rpcParameters, accountAddress) if (err != nil) != tt.wantErr { t.Errorf("GetNonceAtWithRetry() error = %v, wantErr %v", err, tt.wantErr) return @@ -359,3 +350,64 @@ func TestUtilsStruct_GetNonceAtWithRetry(t *testing.T) { }) } } + +func TestClientStruct_GetBlockByNumberWithRetry(t *testing.T) { + var blockNumber *big.Int + + type args struct { + header *types.Header + headerErr error + } + + tests := []struct { + name string + args args + want *types.Header + wantErr bool + }{ + { + name: "Test 1: When GetBlockByNumberWithRetry executes successfully", + args: args{ + header: &types.Header{ + Number: big.NewInt(123), + }, + }, + want: &types.Header{ + Number: big.NewInt(123), + }, + wantErr: false, + }, + { + name: "Test 2: When there is an error in getting block header", + args: args{ + headerErr: errors.New("header error"), + }, + want: nil, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + retryMock := new(mocks.RetryUtils) + clientMock := new(mocks.ClientUtils) + optionsPackageStruct := OptionsPackageStruct{ + RetryInterface: retryMock, + ClientInterface: clientMock, + } + + StartRazor(optionsPackageStruct) + clientMock.On("HeaderByNumber", mock.AnythingOfType("*ethclient.Client"), context.Background(), blockNumber).Return(tt.args.header, tt.args.headerErr) + retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) + + clientUtils := ClientStruct{} + got, err := clientUtils.GetBlockByNumberWithRetry(rpcParameters, blockNumber) + if (err != nil) != tt.wantErr { + t.Errorf("GetBlockByNumberWithRetry() error = %v, wantErr %v", err, tt.wantErr) + return + } + if (got == nil && tt.want != nil) || (got != nil && tt.want == nil) || (got != nil && got.Number.Cmp(tt.want.Number) != 0) { + t.Errorf("GetBlockByNumberWithRetry() got = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/utils/common.go b/utils/common.go index d329aac31..7d7a592a9 100644 --- a/utils/common.go +++ b/utils/common.go @@ -3,7 +3,6 @@ package utils import ( "context" "errors" - Types "github.com/ethereum/go-ethereum/core/types" "math/big" "os" "path/filepath" @@ -11,9 +10,10 @@ import ( "razor/core" "razor/core/types" "razor/logger" + "razor/rpc" "time" - "github.com/avast/retry-go" + Types "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/ethclient" @@ -30,34 +30,24 @@ func (*UtilsStruct) ConnectToClient(provider string) *ethclient.Client { return client } -func (*UtilsStruct) FetchBalance(client *ethclient.Client, accountAddress string) (*big.Int, error) { - var ( - balance *big.Int - err error - ) - err = retry.Do( - func() error { - address := common.HexToAddress(accountAddress) - erc20Contract := UtilsInterface.GetTokenManager(client) - opts := UtilsInterface.GetOptions() - balance, err = CoinInterface.BalanceOf(erc20Contract, &opts, address) - if err != nil { - log.Error("Error in fetching balance....Retrying") - return err - } - return nil - }, RetryInterface.RetryAttempts(core.MaxRetries)) +func (*UtilsStruct) FetchBalance(rpcParameters rpc.RPCParameters, accountAddress string) (*big.Int, error) { + address := common.HexToAddress(accountAddress) + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, CoinInterface, "BalanceOf", address) if err != nil { return big.NewInt(0), err } - return balance, nil + return returnedValues[0].Interface().(*big.Int), nil } -func (*UtilsStruct) GetBufferedState(client *ethclient.Client, header *Types.Header, buffer int32) (int64, error) { - stateBuffer, err := UtilsInterface.GetStateBuffer(client) +func (*UtilsStruct) Allowance(rpcParameters rpc.RPCParameters, owner common.Address, spender common.Address) (*big.Int, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, CoinInterface, "Allowance", owner, spender) if err != nil { - return -1, err + return big.NewInt(0), err } + return returnedValues[0].Interface().(*big.Int), nil +} + +func (*UtilsStruct) GetBufferedState(header *Types.Header, stateBuffer uint64, buffer int32) (int64, error) { lowerLimit := (core.StateLength * uint64(buffer)) / 100 upperLimit := core.StateLength - (core.StateLength*uint64(buffer))/100 if header.Time%(core.StateLength) > upperLimit-stateBuffer || header.Time%(core.StateLength) < lowerLimit+stateBuffer { @@ -67,29 +57,43 @@ func (*UtilsStruct) GetBufferedState(client *ethclient.Client, header *Types.Hea return int64(state % core.NumberOfStates), nil } -func (*UtilsStruct) CheckTransactionReceipt(client *ethclient.Client, _txHash string) int { +func (*UtilsStruct) CheckTransactionReceipt(rpcParameters rpc.RPCParameters, _txHash string) int { txHash := common.HexToHash(_txHash) - tx, err := ClientInterface.TransactionReceipt(client, context.Background(), txHash) + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, ClientInterface, "TransactionReceipt", rpcParameters.Ctx, txHash) if err != nil { return -1 } - return int(tx.Status) + + txnReceipt := returnedValues[0].Interface().(*Types.Receipt) + return int(txnReceipt.Status) } -func (*UtilsStruct) WaitForBlockCompletion(client *ethclient.Client, hashToRead string) error { +func (*UtilsStruct) WaitForBlockCompletion(rpcParameters rpc.RPCParameters, hashToRead string) error { + ctx, cancel := context.WithTimeout(context.Background(), core.BlockCompletionTimeout*time.Second) + defer cancel() + for i := 0; i < core.BlockCompletionAttempts; i++ { - log.Debug("Checking if transaction is mined....") - transactionStatus := UtilsInterface.CheckTransactionReceipt(client, hashToRead) - if transactionStatus == 0 { - err := errors.New("transaction mining unsuccessful") - log.Error(err) - return err - } else if transactionStatus == 1 { - log.Info("Transaction mined successfully") - return nil + select { + case <-ctx.Done(): + log.Error("Timeout: WaitForBlockCompletion took too long") + return errors.New("timeout exceeded for transaction mining") + default: + log.Debug("Checking if transaction is mined....") + transactionStatus := UtilsInterface.CheckTransactionReceipt(rpcParameters, hashToRead) + + if transactionStatus == 0 { + err := errors.New("transaction mining unsuccessful") + log.Error(err) + return err + } else if transactionStatus == 1 { + log.Info("Transaction mined successfully") + return nil + } + + time.Sleep(core.BlockCompletionAttemptRetryDelay * time.Second) } - Time.Sleep(core.BlockCompletionAttemptRetryDelay * time.Second) } + log.Info("Max retries for WaitForBlockCompletion attempted!") return errors.New("maximum attempts failed for transaction mining") } @@ -132,13 +136,13 @@ func (*UtilsStruct) IsFlagPassed(name string) bool { return found } -func (*UtilsStruct) CheckEthBalanceIsZero(client *ethclient.Client, address string) { - ethBalance, err := ClientInterface.BalanceAtWithRetry(client, common.HexToAddress(address)) +func (*UtilsStruct) CheckEthBalanceIsZero(rpcParameters rpc.RPCParameters, address string) { + ethBalance, err := ClientInterface.BalanceAtWithRetry(rpcParameters, common.HexToAddress(address)) if err != nil { - log.Fatalf("Error in fetching sFuel balance of the account: %s\n%s", address, err) + log.Fatalf("Error in fetching sFUEL balance of the account: %s\n%s", address, err) } if ethBalance.Cmp(big.NewInt(0)) == 0 { - log.Fatal("sFuel balance is 0, Aborting...") + log.Fatal("sFUEL balance is 0, Aborting...") } } @@ -161,15 +165,15 @@ func GetStateName(stateNumber int64) string { return stateName } -func (*UtilsStruct) AssignStakerId(flagSet *pflag.FlagSet, client *ethclient.Client, address string) (uint32, error) { +func (*UtilsStruct) AssignStakerId(rpcParameters rpc.RPCParameters, flagSet *pflag.FlagSet, address string) (uint32, error) { if UtilsInterface.IsFlagPassed("stakerId") { return UtilsInterface.GetUint32(flagSet, "stakerId") } - return UtilsInterface.GetStakerId(client, address) + return UtilsInterface.GetStakerId(rpcParameters, address) } -func (*UtilsStruct) GetEpoch(client *ethclient.Client) (uint32, error) { - latestHeader, err := ClientInterface.GetLatestBlockWithRetry(client) +func (*UtilsStruct) GetEpoch(rpcParameters rpc.RPCParameters) (uint32, error) { + latestHeader, err := ClientInterface.GetLatestBlockWithRetry(rpcParameters) if err != nil { log.Error("Error in fetching block: ", err) return 0, err @@ -178,28 +182,20 @@ func (*UtilsStruct) GetEpoch(client *ethclient.Client) (uint32, error) { return uint32(epoch), nil } -func (*UtilsStruct) CalculateBlockTime(client *ethclient.Client) int64 { - latestBlock, err := ClientInterface.GetLatestBlockWithRetry(client) +func (*UtilsStruct) CalculateBlockTime(rpcParameters rpc.RPCParameters) int64 { + latestBlock, err := ClientInterface.GetLatestBlockWithRetry(rpcParameters) if err != nil { log.Fatalf("Error in fetching latest Block: %s", err) } latestBlockNumber := latestBlock.Number - lastSecondBlock, err := ClientInterface.HeaderByNumber(client, context.Background(), big.NewInt(1).Sub(latestBlockNumber, big.NewInt(1))) + lastSecondBlock, err := ClientInterface.GetBlockByNumberWithRetry(rpcParameters, big.NewInt(1).Sub(latestBlockNumber, big.NewInt(1))) if err != nil { log.Fatalf("Error in fetching last second Block: %s", err) } return int64(latestBlock.Time - lastSecondBlock.Time) } -func (*UtilsStruct) GetRemainingTimeOfCurrentState(client *ethclient.Client, bufferPercent int32) (int64, error) { - block, err := ClientInterface.GetLatestBlockWithRetry(client) - if err != nil { - return 0, err - } - stateBuffer, err := UtilsInterface.GetStateBuffer(client) - if err != nil { - return 0, err - } +func (*UtilsStruct) GetRemainingTimeOfCurrentState(block *Types.Header, stateBuffer uint64, bufferPercent int32) (int64, error) { timeRemaining := core.StateLength - (block.Time % core.StateLength) upperLimit := ((core.StateLength * uint64(bufferPercent)) / 100) + stateBuffer @@ -219,8 +215,8 @@ func (*UtilsStruct) Prng(max uint32, prngHashes []byte) *big.Int { return sum.Mod(sum, maxBigInt) } -func (*UtilsStruct) EstimateBlockNumberAtEpochBeginning(client *ethclient.Client, currentBlockNumber *big.Int) (*big.Int, error) { - block, err := ClientInterface.HeaderByNumber(client, context.Background(), currentBlockNumber) +func (*UtilsStruct) EstimateBlockNumberAtEpochBeginning(rpcParameters rpc.RPCParameters, currentBlockNumber *big.Int) (*big.Int, error) { + block, err := ClientInterface.GetBlockByNumberWithRetry(rpcParameters, currentBlockNumber) if err != nil { log.Error("Error in fetching block: ", err) return nil, err @@ -228,7 +224,7 @@ func (*UtilsStruct) EstimateBlockNumberAtEpochBeginning(client *ethclient.Client currentEpoch := block.Time / core.EpochLength previousBlockNumber := block.Number.Uint64() - core.StateLength - previousBlock, err := ClientInterface.HeaderByNumber(client, context.Background(), big.NewInt(int64(previousBlockNumber))) + previousBlock, err := ClientInterface.GetBlockByNumberWithRetry(rpcParameters, big.NewInt(int64(previousBlockNumber))) if err != nil { log.Error("Err in fetching Previous block: ", err) return nil, err @@ -237,20 +233,21 @@ func (*UtilsStruct) EstimateBlockNumberAtEpochBeginning(client *ethclient.Client previousBlockAssumedTimestamp := block.Time - core.EpochLength previousEpoch := previousBlockActualTimestamp / core.EpochLength if previousBlockActualTimestamp > previousBlockAssumedTimestamp && previousEpoch != currentEpoch-1 { - return UtilsInterface.EstimateBlockNumberAtEpochBeginning(client, big.NewInt(int64(previousBlockNumber))) + return UtilsInterface.EstimateBlockNumberAtEpochBeginning(rpcParameters, big.NewInt(int64(previousBlockNumber))) } return big.NewInt(int64(previousBlockNumber)), nil } -func (*FileStruct) SaveDataToCommitJsonFile(filePath string, epoch uint32, commitData types.CommitData) error { +func (*FileStruct) SaveDataToCommitJsonFile(filePath string, epoch uint32, commitData types.CommitData, commitment [32]byte) error { var data types.CommitFileData data.Epoch = epoch data.AssignedCollections = commitData.AssignedCollections data.SeqAllottedCollections = commitData.SeqAllottedCollections data.Leaves = commitData.Leaves + data.Commitment = commitment jsonData, err := JsonInterface.Marshal(data) if err != nil { diff --git a/utils/common_test.go b/utils/common_test.go index ea5065190..8aef3d599 100644 --- a/utils/common_test.go +++ b/utils/common_test.go @@ -12,7 +12,6 @@ import ( "testing" "github.com/avast/retry-go" - "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethclient" "github.com/spf13/pflag" @@ -43,8 +42,6 @@ func TestCheckError(t *testing.T) { } func TestCalculateBlockTime(t *testing.T) { - var client *ethclient.Client - type args struct { latestBlock *types.Header latestBlockErr error @@ -99,9 +96,9 @@ func TestCalculateBlockTime(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -112,12 +109,12 @@ func TestCalculateBlockTime(t *testing.T) { } utils := StartRazor(optionsPackageStruct) - clientUtilsMock.On("GetLatestBlockWithRetry", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.latestBlock, tt.args.latestBlockErr) - clientUtilsMock.On("HeaderByNumber", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything).Return(tt.args.lastSecondBlock, tt.args.lastSecondBlockErr) + clientUtilsMock.On("GetLatestBlockWithRetry", mock.Anything).Return(tt.args.latestBlock, tt.args.latestBlockErr) + clientUtilsMock.On("GetBlockByNumberWithRetry", mock.Anything, mock.Anything).Return(tt.args.lastSecondBlock, tt.args.lastSecondBlockErr) fatal = false - utils.CalculateBlockTime(client) + utils.CalculateBlockTime(rpcParameters) if fatal != tt.expectedFatal { t.Error("The CalculateBlockTime function didn't execute as expected") } @@ -126,7 +123,6 @@ func TestCalculateBlockTime(t *testing.T) { } func TestCheckEthBalanceIsZero(t *testing.T) { - var client *ethclient.Client var address string type args struct { @@ -162,9 +158,9 @@ func TestCheckEthBalanceIsZero(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -179,7 +175,7 @@ func TestCheckEthBalanceIsZero(t *testing.T) { fatal = false - utils.CheckEthBalanceIsZero(client, address) + utils.CheckEthBalanceIsZero(rpcParameters, address) if fatal != tt.expectedFatal { t.Error("The CheckEthBalanceIsZero function didn't execute as expected") } @@ -188,7 +184,6 @@ func TestCheckEthBalanceIsZero(t *testing.T) { } func TestCheckTransactionReceipt(t *testing.T) { - var client *ethclient.Client var txHash string type args struct { @@ -219,24 +214,27 @@ func TestCheckTransactionReceipt(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { clientMock := new(mocks.ClientUtils) + retryMock := new(mocks.RetryUtils) optionsPackageStruct := OptionsPackageStruct{ ClientInterface: clientMock, + RetryInterface: retryMock, } utils := StartRazor(optionsPackageStruct) - clientMock.On("TransactionReceipt", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything).Return(tt.args.tx, tt.args.txErr) + clientMock.On("TransactionReceipt", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.tx, tt.args.txErr) + retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) fatal = false - utils.CheckTransactionReceipt(client, txHash) + utils.CheckTransactionReceipt(rpcParameters, txHash) if fatal != tt.expectedFatal { t.Error("The CheckTransactionReceipt function didn't execute as expected") } @@ -271,9 +269,9 @@ func TestConnectToClient(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -297,9 +295,7 @@ func TestConnectToClient(t *testing.T) { } func TestFetchBalance(t *testing.T) { - var client *ethclient.Client var accountAddress string - var callOpts bind.CallOpts type args struct { erc20Contract *bindings.RAZOR @@ -344,12 +340,10 @@ func TestFetchBalance(t *testing.T) { } utils := StartRazor(optionsPackageStruct) - utilsMock.On("GetTokenManager", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.erc20Contract) - utilsMock.On("GetOptions").Return(callOpts) erc20Mock.On("BalanceOf", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.balance, tt.args.balanceErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.FetchBalance(client, accountAddress) + got, err := utils.FetchBalance(rpcParameters, accountAddress) if (err != nil) != tt.wantErr { t.Errorf("FetchBalance() error = %v, wantErr %v", err, tt.wantErr) return @@ -362,13 +356,10 @@ func TestFetchBalance(t *testing.T) { } func TestGetBufferedState(t *testing.T) { - var client *ethclient.Client - type args struct { - block *types.Header - buffer int32 - stateBuffer uint64 - stateBufferErr error + block *types.Header + buffer int32 + stateBuffer uint64 } tests := []struct { name string @@ -414,36 +405,12 @@ func TestGetBufferedState(t *testing.T) { want: -1, wantErr: false, }, - { - name: "Test 4: When there is an error in getting stateBuffer", - args: args{ - block: &types.Header{ - Time: 100, - }, - buffer: 2, - stateBufferErr: errors.New("error in getting stateBuffer"), - }, - - want: -1, - wantErr: true, - }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + utils := StartRazor(OptionsPackageStruct{}) - utilsMock := new(mocks.Utils) - clientUtilsMock := new(mocks.ClientUtils) - - optionsPackageStruct := OptionsPackageStruct{ - UtilsInterface: utilsMock, - ClientInterface: clientUtilsMock, - } - - utils := StartRazor(optionsPackageStruct) - - utilsMock.On("GetStateBuffer", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.stateBuffer, tt.args.stateBufferErr) - - got, err := utils.GetBufferedState(client, tt.args.block, tt.args.buffer) + got, err := utils.GetBufferedState(tt.args.block, tt.args.stateBuffer, tt.args.buffer) if (err != nil) != tt.wantErr { t.Errorf("GetBufferedState() error = %v, wantErr %v", err, tt.wantErr) return @@ -456,8 +423,6 @@ func TestGetBufferedState(t *testing.T) { } func TestGetEpoch(t *testing.T) { - var client *ethclient.Client - type args struct { latestHeader *types.Header latestHeaderErr error @@ -499,9 +464,9 @@ func TestGetEpoch(t *testing.T) { } utils := StartRazor(optionsPackageStruct) - clientUtilsMock.On("GetLatestBlockWithRetry", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.latestHeader, tt.args.latestHeaderErr) + clientUtilsMock.On("GetLatestBlockWithRetry", mock.Anything).Return(tt.args.latestHeader, tt.args.latestHeaderErr) - got, err := utils.GetEpoch(client) + got, err := utils.GetEpoch(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetEpoch() error = %v, wantErr %v", err, tt.wantErr) return @@ -575,7 +540,6 @@ func TestGetStateName(t *testing.T) { } func TestWaitForBlockCompletion(t *testing.T) { - var client *ethclient.Client var hashToRead string type args struct { @@ -619,17 +583,17 @@ func TestWaitForBlockCompletion(t *testing.T) { } utils := StartRazor(optionsPackageStruct) - utilsMock.On("CheckTransactionReceipt", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.transactionStatus) + utilsMock.On("CheckTransactionReceipt", mock.Anything, mock.Anything).Return(tt.args.transactionStatus) timeMock.On("Sleep", mock.Anything).Return() - gotErr := utils.WaitForBlockCompletion(client, hashToRead) + gotErr := utils.WaitForBlockCompletion(rpcParameters, hashToRead) if gotErr == nil || tt.want == nil { if gotErr != tt.want { - t.Errorf("Error for stake function, got = %v, want %v", gotErr, tt.want) + t.Errorf("Error for WaitForBlockCompletion function, got = %v, want %v", gotErr, tt.want) } } else { if gotErr.Error() != tt.want.Error() { - t.Errorf("Error for stake function, got = %v, want %v", gotErr, tt.want) + t.Errorf("Error for WaitForBlockCompletion function, got = %v, want %v", gotErr, tt.want) } } }) @@ -796,7 +760,6 @@ func TestIsValidateAddress(t *testing.T) { func TestAssignStakerId(t *testing.T) { var flagSet *pflag.FlagSet - var client *ethclient.Client var address string type args struct { @@ -841,9 +804,9 @@ func TestAssignStakerId(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -856,11 +819,11 @@ func TestAssignStakerId(t *testing.T) { utilsMock.On("IsFlagPassed", mock.AnythingOfType("string")).Return(tt.args.flagPassed) utilsMock.On("GetUint32", mock.Anything, mock.AnythingOfType("string")).Return(tt.args.flagSetStakerId, tt.args.flagSetStakerIdErr) - utilsMock.On("GetStakerId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.stakerId, tt.args.stakerIdErr) + utilsMock.On("GetStakerId", mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) fatal = false - _, err := utils.AssignStakerId(flagSet, client, address) + _, err := utils.AssignStakerId(rpcParameters, flagSet, address) if fatal != tt.expectedFatal { t.Error("The AssignStakerId function didn't execute as expected") } @@ -908,9 +871,9 @@ func TestAssignLogFile(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -937,15 +900,10 @@ func TestAssignLogFile(t *testing.T) { } func TestGetRemainingTimeOfCurrentState(t *testing.T) { - var ( - client *ethclient.Client - bufferPercent int32 - ) type args struct { - block *types.Header - blockErr error - stateBuffer uint64 - stateBufferErr error + block *types.Header + stateBuffer uint64 + bufferPercent int32 } tests := []struct { name string @@ -962,38 +920,11 @@ func TestGetRemainingTimeOfCurrentState(t *testing.T) { want: 85, wantErr: false, }, - { - name: "Test 2: When there is an error in getting stateBuffer", - args: args{ - block: &types.Header{}, - stateBufferErr: errors.New("error in getting stateBuffer"), - }, - want: 0, - wantErr: true, - }, - { - name: "Test 3: When there is an error in getting block", - args: args{ - blockErr: errors.New("error in getting block"), - }, - want: 0, - wantErr: true, - }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - utilsMock := new(mocks.Utils) - clientUtilsMock := new(mocks.ClientUtils) - - optionsPackageStruct := OptionsPackageStruct{ - UtilsInterface: utilsMock, - ClientInterface: clientUtilsMock, - } - utils := StartRazor(optionsPackageStruct) - - utilsMock.On("GetStateBuffer", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.stateBuffer, tt.args.stateBufferErr) - clientUtilsMock.On("GetLatestBlockWithRetry", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.block, tt.args.blockErr) - got, err := utils.GetRemainingTimeOfCurrentState(client, bufferPercent) + utils := StartRazor(OptionsPackageStruct{}) + got, err := utils.GetRemainingTimeOfCurrentState(tt.args.block, tt.args.stateBuffer, tt.args.bufferPercent) if (err != nil) != tt.wantErr { t.Errorf("GetRemainingTimeOfCurrentState() error = %v, wantErr %v", err, tt.wantErr) return @@ -1064,10 +995,7 @@ func TestPrng(t *testing.T) { } func TestEstimateBlockNumberAtEpochBeginning(t *testing.T) { - var ( - client *ethclient.Client - currentBlockNumber *big.Int - ) + var currentBlockNumber *big.Int type args struct { block *types.Header blockErr error @@ -1109,9 +1037,9 @@ func TestEstimateBlockNumberAtEpochBeginning(t *testing.T) { } utils := StartRazor(optionsPackageStruct) - clientMock.On("HeaderByNumber", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything).Return(tt.args.block, tt.args.blockErr) - clientMock.On("HeaderByNumber", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything).Return(tt.args.previousBlock, tt.args.previousBlockErr) - got, err := utils.EstimateBlockNumberAtEpochBeginning(client, currentBlockNumber) + clientMock.On("GetBlockByNumberWithRetry", mock.Anything, mock.Anything).Return(tt.args.block, tt.args.blockErr) + clientMock.On("GetBlockByNumberWithRetry", mock.Anything, mock.Anything).Return(tt.args.previousBlock, tt.args.previousBlockErr) + got, err := utils.EstimateBlockNumberAtEpochBeginning(rpcParameters, currentBlockNumber) if (err != nil) != tt.wantErr { t.Errorf("EstimateBlockNumberAtEpochBeginning() error = %v, wantErr %v", err, tt.wantErr) return @@ -1128,6 +1056,7 @@ func TestSaveDataToCommitJsonFile(t *testing.T) { filePath string epoch uint32 commitData Types.CommitData + commitment [32]byte ) type args struct { jsonData []byte @@ -1177,7 +1106,7 @@ func TestSaveDataToCommitJsonFile(t *testing.T) { osMock.On("WriteFile", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.writeFileErr) fileUtils := FileStruct{} - if err := fileUtils.SaveDataToCommitJsonFile(filePath, epoch, commitData); (err != nil) != tt.wantErr { + if err := fileUtils.SaveDataToCommitJsonFile(filePath, epoch, commitData, commitment); (err != nil) != tt.wantErr { t.Errorf("SaveDataToCommitJsonFile() error = %v, wantErr %v", err, tt.wantErr) } }) diff --git a/utils/contract-manager_test.go b/utils/contract-manager_test.go index 08ddc0b3f..da989aa57 100644 --- a/utils/contract-manager_test.go +++ b/utils/contract-manager_test.go @@ -38,9 +38,9 @@ func TestGetStakeManager(t *testing.T) { expectedFatal: true, }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -91,9 +91,9 @@ func TestGetStakedToken(t *testing.T) { expectedFatal: true, }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -143,9 +143,9 @@ func TestGetTokenManager(t *testing.T) { expectedFatal: true, }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -195,9 +195,9 @@ func TestGetAssetManager(t *testing.T) { expectedFatal: true, }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -247,9 +247,9 @@ func TestGetBlockManager(t *testing.T) { expectedFatal: true, }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -299,9 +299,9 @@ func TestGetVoteManager(t *testing.T) { expectedFatal: true, }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { diff --git a/utils/interface.go b/utils/interface.go index cc7ee2274..aafc18a36 100644 --- a/utils/interface.go +++ b/utils/interface.go @@ -3,7 +3,6 @@ package utils import ( "context" "crypto/ecdsa" - "github.com/ethereum/go-ethereum/rpc" "io" "io/fs" "math/big" @@ -11,8 +10,11 @@ import ( "razor/cache" "razor/core/types" "razor/pkg/bindings" + "razor/rpc" "time" + RPC "github.com/ethereum/go-ethereum/rpc" + "github.com/avast/retry-go" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" @@ -71,67 +73,74 @@ var GasInterface GasUtils type Utils interface { MultiplyFloatAndBigInt(bigIntVal *big.Int, floatingVal float64) *big.Int - GetTxnOpts(transactionData types.TransactionOptions) *bind.TransactOpts + GetTxnOpts(rpcParameters rpc.RPCParameters, transactionData types.TransactionOptions) (*bind.TransactOpts, error) GetBlockManager(client *ethclient.Client) *bindings.BlockManager GetOptions() bind.CallOpts - GetNumberOfProposedBlocks(client *ethclient.Client, epoch uint32) (uint8, error) - GetSortedProposedBlockId(client *ethclient.Client, epoch uint32, index *big.Int) (uint32, error) - FetchPreviousValue(client *ethclient.Client, epoch uint32, assetId uint16) (*big.Int, error) - GetBlock(client *ethclient.Client, epoch uint32) (bindings.StructsBlock, error) - GetMaxAltBlocks(client *ethclient.Client) (uint8, error) - GetMinSafeRazor(client *ethclient.Client) (*big.Int, error) - GetMinStakeAmount(client *ethclient.Client) (*big.Int, error) - GetStateBuffer(client *ethclient.Client) (uint64, error) - GetProposedBlock(client *ethclient.Client, epoch uint32, proposedBlockId uint32) (bindings.StructsBlock, error) - GetSortedProposedBlockIds(client *ethclient.Client, epoch uint32) ([]uint32, error) - GetBlockIndexToBeConfirmed(client *ethclient.Client) (int8, error) + GetNumberOfProposedBlocks(rpcParameters rpc.RPCParameters, epoch uint32) (uint8, error) + GetSortedProposedBlockId(rpcParameters rpc.RPCParameters, epoch uint32, index *big.Int) (uint32, error) + FetchPreviousValue(rpcParameters rpc.RPCParameters, epoch uint32, assetId uint16) (*big.Int, error) + GetBlock(rpcParameters rpc.RPCParameters, epoch uint32) (bindings.StructsBlock, error) + GetMaxAltBlocks(rpcParameters rpc.RPCParameters) (uint8, error) + GetMinSafeRazor(rpcParameters rpc.RPCParameters) (*big.Int, error) + GetMinStakeAmount(rpcParameters rpc.RPCParameters) (*big.Int, error) + GetStateBuffer(rpcParameters rpc.RPCParameters) (uint64, error) + GetProposedBlock(rpcParameters rpc.RPCParameters, epoch uint32, proposedBlockId uint32) (bindings.StructsBlock, error) + GetSortedProposedBlockIds(rpcParameters rpc.RPCParameters, epoch uint32) ([]uint32, error) + GetBlockIndexToBeConfirmed(rpcParameters rpc.RPCParameters) (int8, error) GetBlockManagerWithOpts(client *ethclient.Client) (*bindings.BlockManager, bind.CallOpts) GetStakeManager(client *ethclient.Client) *bindings.StakeManager GetStakeManagerWithOpts(client *ethclient.Client) (*bindings.StakeManager, bind.CallOpts) - GetStaker(client *ethclient.Client, stakerId uint32) (bindings.StructsStaker, error) - GetStake(client *ethclient.Client, stakerId uint32) (*big.Int, error) - GetStakerId(client *ethclient.Client, address string) (uint32, error) - GetNumberOfStakers(client *ethclient.Client) (uint32, error) - GetLock(client *ethclient.Client, address string, stakerId uint32, lockType uint8) (types.Locks, error) - GetWithdrawInitiationPeriod(client *ethclient.Client) (uint16, error) - GetMaxCommission(client *ethclient.Client) (uint8, error) - GetEpochLimitForUpdateCommission(client *ethclient.Client) (uint16, error) + GetStaker(rpcParameters rpc.RPCParameters, stakerId uint32) (bindings.StructsStaker, error) + GetStake(rpcParameters rpc.RPCParameters, stakerId uint32) (*big.Int, error) + GetStakerId(rpcParameters rpc.RPCParameters, address string) (uint32, error) + GetNumberOfStakers(rpcParameters rpc.RPCParameters) (uint32, error) + GetLock(rpcParameters rpc.RPCParameters, address string, stakerId uint32, lockType uint8) (types.Locks, error) + GetWithdrawInitiationPeriod(rpcParameters rpc.RPCParameters) (uint16, error) + GetMaxCommission(rpcParameters rpc.RPCParameters) (uint8, error) + GetEpochLimitForUpdateCommission(rpcParameters rpc.RPCParameters) (uint16, error) + StakerInfo(rpcParameters rpc.RPCParameters, stakerId uint32) (types.Staker, error) + GetMaturity(rpcParameters rpc.RPCParameters, age uint32) (uint16, error) + GetBountyLock(rpcParameters rpc.RPCParameters, bountyId uint32) (types.BountyLock, error) GetVoteManagerWithOpts(client *ethclient.Client) (*bindings.VoteManager, bind.CallOpts) - GetCommitment(client *ethclient.Client, address string) (types.Commitment, error) - GetVoteValue(client *ethclient.Client, epoch uint32, stakerId uint32, medianIndex uint16) (*big.Int, error) - GetInfluenceSnapshot(client *ethclient.Client, stakerId uint32, epoch uint32) (*big.Int, error) - GetStakeSnapshot(client *ethclient.Client, stakerId uint32, epoch uint32) (*big.Int, error) - GetTotalInfluenceRevealed(client *ethclient.Client, epoch uint32, medianIndex uint16) (*big.Int, error) - GetEpochLastCommitted(client *ethclient.Client, stakerId uint32) (uint32, error) - GetEpochLastRevealed(client *ethclient.Client, stakerId uint32) (uint32, error) + GetCommitment(rpcParameters rpc.RPCParameters, address string) (types.Commitment, error) + GetVoteValue(rpcParameters rpc.RPCParameters, epoch uint32, stakerId uint32, medianIndex uint16) (*big.Int, error) + GetInfluenceSnapshot(rpcParameters rpc.RPCParameters, stakerId uint32, epoch uint32) (*big.Int, error) + GetStakeSnapshot(rpcParameters rpc.RPCParameters, stakerId uint32, epoch uint32) (*big.Int, error) + GetTotalInfluenceRevealed(rpcParameters rpc.RPCParameters, epoch uint32, medianIndex uint16) (*big.Int, error) + GetEpochLastCommitted(rpcParameters rpc.RPCParameters, stakerId uint32) (uint32, error) + GetEpochLastRevealed(rpcParameters rpc.RPCParameters, stakerId uint32) (uint32, error) GetVoteManager(client *ethclient.Client) *bindings.VoteManager GetCollectionManager(client *ethclient.Client) *bindings.CollectionManager GetCollectionManagerWithOpts(client *ethclient.Client) (*bindings.CollectionManager, bind.CallOpts) - GetNumCollections(client *ethclient.Client) (uint16, error) - GetActiveJob(client *ethclient.Client, jobId uint16) (bindings.StructsJob, error) - GetCollection(client *ethclient.Client, collectionId uint16) (bindings.StructsCollection, error) + GetNumCollections(rpcParameters rpc.RPCParameters) (uint16, error) + GetNumJobs(rpcParameters rpc.RPCParameters) (uint16, error) + GetActiveJob(rpcParameters rpc.RPCParameters, jobId uint16) (bindings.StructsJob, error) + GetCollection(rpcParameters rpc.RPCParameters, collectionId uint16) (bindings.StructsCollection, error) GetActiveCollection(collectionsCache *cache.CollectionsCache, collectionId uint16) (bindings.StructsCollection, error) - Aggregate(client *ethclient.Client, previousEpoch uint32, collection bindings.StructsCollection, commitParams *types.CommitParams) (*big.Int, error) + Aggregate(rpcParameters rpc.RPCParameters, previousEpoch uint32, collection bindings.StructsCollection, commitParams *types.CommitParams) (*big.Int, error) GetDataToCommitFromJobs(jobs []bindings.StructsJob, commitParams *types.CommitParams) ([]*big.Int, []uint8) GetDataToCommitFromJob(job bindings.StructsJob, commitParams *types.CommitParams) (*big.Int, error) - GetAssignedCollections(client *ethclient.Client, numActiveCollections uint16, seed []byte) (map[int]bool, []*big.Int, error) - GetLeafIdOfACollection(client *ethclient.Client, collectionId uint16) (uint16, error) - GetCollectionIdFromIndex(client *ethclient.Client, medianIndex uint16) (uint16, error) - GetCollectionIdFromLeafId(client *ethclient.Client, leafId uint16) (uint16, error) - GetNumActiveCollections(client *ethclient.Client) (uint16, error) - GetAggregatedDataOfCollection(client *ethclient.Client, collectionId uint16, epoch uint32, commitParams *types.CommitParams) (*big.Int, error) - GetJobs(client *ethclient.Client) ([]bindings.StructsJob, error) - GetAllCollections(client *ethclient.Client) ([]bindings.StructsCollection, error) - GetActiveCollectionIds(client *ethclient.Client) ([]uint16, error) - HandleOfficialJobsFromJSONFile(client *ethclient.Client, collection bindings.StructsCollection, dataString string, commitParams *types.CommitParams) ([]bindings.StructsJob, []uint16) + GetAssignedCollections(rpcParameters rpc.RPCParameters, numActiveCollections uint16, seed []byte) (map[int]bool, []*big.Int, error) + GetLeafIdOfACollection(rpcParameters rpc.RPCParameters, collectionId uint16) (uint16, error) + GetSaltFromBlockchain(rpcParameters rpc.RPCParameters) ([32]byte, error) + GetCollectionIdFromIndex(rpcParameters rpc.RPCParameters, medianIndex uint16) (uint16, error) + GetCollectionIdFromLeafId(rpcParameters rpc.RPCParameters, leafId uint16) (uint16, error) + GetNumActiveCollections(rpcParameters rpc.RPCParameters) (uint16, error) + GetAggregatedDataOfCollection(rpcParameters rpc.RPCParameters, collectionId uint16, epoch uint32, commitParams *types.CommitParams) (*big.Int, error) + GetJobs(rpcParameters rpc.RPCParameters) ([]bindings.StructsJob, error) + GetAllCollections(rpcParameters rpc.RPCParameters) ([]bindings.StructsCollection, error) + GetActiveCollectionIds(rpcParameters rpc.RPCParameters) ([]uint16, error) + GetActiveStatus(rpcParameters rpc.RPCParameters, id uint16) (bool, error) + HandleOfficialJobsFromJSONFile(collection bindings.StructsCollection, dataString string, commitParams *types.CommitParams) ([]bindings.StructsJob, []uint16) ConnectToClient(provider string) *ethclient.Client - FetchBalance(client *ethclient.Client, accountAddress string) (*big.Int, error) - GetBufferedState(client *ethclient.Client, header *Types.Header, buffer int32) (int64, error) - WaitForBlockCompletion(client *ethclient.Client, hashToRead string) error - CheckEthBalanceIsZero(client *ethclient.Client, address string) - AssignStakerId(flagSet *pflag.FlagSet, client *ethclient.Client, address string) (uint32, error) - GetEpoch(client *ethclient.Client) (uint32, error) - CalculateBlockTime(client *ethclient.Client) int64 + FetchBalance(rpcParameters rpc.RPCParameters, accountAddress string) (*big.Int, error) + Allowance(rpcParameters rpc.RPCParameters, owner common.Address, spender common.Address) (*big.Int, error) + GetBufferedState(header *Types.Header, stateBuffer uint64, buffer int32) (int64, error) + WaitForBlockCompletion(rpcManager rpc.RPCParameters, hashToRead string) error + CheckEthBalanceIsZero(rpcParameters rpc.RPCParameters, address string) + AssignStakerId(rpcParameters rpc.RPCParameters, flagSet *pflag.FlagSet, address string) (uint32, error) + GetEpoch(rpcParameters rpc.RPCParameters) (uint32, error) + CalculateBlockTime(rpcParameters rpc.RPCParameters) int64 IsFlagPassed(name string) bool GetTokenManager(client *ethclient.Client) *bindings.RAZOR GetStakedToken(client *ethclient.Client, tokenAddress common.Address) *bindings.StakedToken @@ -141,21 +150,23 @@ type Utils interface { WriteDataToJSON(fileName string, data map[string]*types.StructsJob) error DeleteJobFromJSON(fileName string, jobId string) error AddJobToJSON(fileName string, job *types.StructsJob) error - CheckTransactionReceipt(client *ethclient.Client, _txHash string) int + CheckTransactionReceipt(rpcManager rpc.RPCParameters, _txHash string) int CalculateSalt(epoch uint32, medians []*big.Int) [32]byte - ToAssign(client *ethclient.Client) (uint16, error) + ToAssign(rpcParameters rpc.RPCParameters) (uint16, error) Prng(max uint32, prngHashes []byte) *big.Int - GetRemainingTimeOfCurrentState(client *ethclient.Client, bufferPercent int32) (int64, error) + GetRemainingTimeOfCurrentState(block *Types.Header, stateBuffer uint64, bufferPercent int32) (int64, error) SecondsToReadableTime(input int) string - EstimateBlockNumberAtEpochBeginning(client *ethclient.Client, currentBlockNumber *big.Int) (*big.Int, error) - GetEpochLastProposed(client *ethclient.Client, stakerId uint32) (uint32, error) + EstimateBlockNumberAtEpochBeginning(rpcParameters rpc.RPCParameters, currentBlockNumber *big.Int) (*big.Int, error) + GetEpochLastProposed(rpcParameters rpc.RPCParameters, stakerId uint32) (uint32, error) + GetConfirmedBlocks(rpcParameters rpc.RPCParameters, epoch uint32) (types.ConfirmedBlock, error) + Disputes(rpcParameters rpc.RPCParameters, epoch uint32, address common.Address) (types.DisputesStruct, error) CheckAmountAndBalance(amountInWei *big.Int, balance *big.Int) *big.Int PasswordPrompt() string AssignPassword(flagSet *pflag.FlagSet) string PrivateKeyPrompt() string GetRogueRandomValue(value int) *big.Int GetStakedTokenManagerWithOpts(client *ethclient.Client, tokenAddress common.Address) (*bindings.StakedToken, bind.CallOpts) - GetStakerSRZRBalance(client *ethclient.Client, staker bindings.StructsStaker) (*big.Int, error) + GetStakerSRZRBalance(rpcParameters rpc.RPCParameters, staker bindings.StructsStaker) (*big.Int, error) CheckPassword(account types.Account) error AccountManagerForKeystore() (types.AccountManagerInterface, error) } @@ -172,15 +183,16 @@ type ClientUtils interface { SuggestGasPrice(client *ethclient.Client, ctx context.Context) (*big.Int, error) EstimateGas(client *ethclient.Client, ctx context.Context, msg ethereum.CallMsg) (uint64, error) FilterLogs(client *ethclient.Client, ctx context.Context, q ethereum.FilterQuery) ([]Types.Log, error) - SuggestGasPriceWithRetry(client *ethclient.Client) (*big.Int, error) - EstimateGasWithRetry(client *ethclient.Client, message ethereum.CallMsg) (uint64, error) - GetLatestBlockWithRetry(client *ethclient.Client) (*Types.Header, error) - FilterLogsWithRetry(client *ethclient.Client, query ethereum.FilterQuery) ([]Types.Log, error) - BalanceAtWithRetry(client *ethclient.Client, account common.Address) (*big.Int, error) - GetNonceAtWithRetry(client *ethclient.Client, accountAddress common.Address) (uint64, error) - PerformBatchCall(client *ethclient.Client, calls []rpc.BatchElem) error - CreateBatchCalls(contractABI *abi.ABI, contractAddress, methodName string, args [][]interface{}) ([]rpc.BatchElem, error) - BatchCall(client *ethclient.Client, contractABI *abi.ABI, contractAddress, methodName string, args [][]interface{}) ([][]interface{}, error) + SuggestGasPriceWithRetry(rpcParameters rpc.RPCParameters) (*big.Int, error) + EstimateGasWithRetry(rpcParameters rpc.RPCParameters, message ethereum.CallMsg) (uint64, error) + GetLatestBlockWithRetry(rpcParameters rpc.RPCParameters) (*Types.Header, error) + GetBlockByNumberWithRetry(rpcParameters rpc.RPCParameters, blockNumber *big.Int) (*Types.Header, error) + FilterLogsWithRetry(rpcParameters rpc.RPCParameters, query ethereum.FilterQuery) ([]Types.Log, error) + BalanceAtWithRetry(rpcParameters rpc.RPCParameters, account common.Address) (*big.Int, error) + GetNonceAtWithRetry(rpcParameters rpc.RPCParameters, accountAddress common.Address) (uint64, error) + PerformBatchCall(rpcParameters rpc.RPCParameters, calls []RPC.BatchElem) error + CreateBatchCalls(contractABI *abi.ABI, contractAddress, methodName string, args [][]interface{}) ([]RPC.BatchElem, error) + BatchCall(rpcParameters rpc.RPCParameters, contractABI *abi.ABI, contractAddress, methodName string, args [][]interface{}) ([][]interface{}, error) } type TimeUtils interface { @@ -195,7 +207,8 @@ type OSUtils interface { } type CoinUtils interface { - BalanceOf(erc20Contract *bindings.RAZOR, opts *bind.CallOpts, account common.Address) (*big.Int, error) + BalanceOf(client *ethclient.Client, account common.Address) (*big.Int, error) + Allowance(client *ethclient.Client, owner common.Address, spender common.Address) (*big.Int, error) } type MerkleTreeInterface interface { @@ -231,6 +244,8 @@ type BlockManagerUtils interface { SortedProposedBlockIds(client *ethclient.Client, arg0 uint32, arg1 *big.Int) (uint32, error) GetBlockIndexToBeConfirmed(client *ethclient.Client) (int8, error) GetEpochLastProposed(client *ethclient.Client, stakerId uint32) (uint32, error) + GetConfirmedBlocks(client *ethclient.Client, epoch uint32) (types.ConfirmedBlock, error) + Disputes(client *ethclient.Client, epoch uint32, address common.Address) (types.DisputesStruct, error) } type StakeManagerUtils interface { @@ -242,6 +257,9 @@ type StakeManagerUtils interface { MaxCommission(client *ethclient.Client) (uint8, error) EpochLimitForUpdateCommission(client *ethclient.Client) (uint16, error) WithdrawInitiationPeriod(client *ethclient.Client) (uint16, error) + StakerInfo(client *ethclient.Client, stakerId uint32) (types.Staker, error) + GetMaturity(client *ethclient.Client, age uint32) (uint16, error) + GetBountyLock(client *ethclient.Client, bountyId uint32) (types.BountyLock, error) } type AssetManagerUtils interface { @@ -251,6 +269,7 @@ type AssetManagerUtils interface { GetJob(client *ethclient.Client, id uint16) (bindings.StructsJob, error) GetCollection(client *ethclient.Client, id uint16) (bindings.StructsCollection, error) GetActiveCollections(client *ethclient.Client) ([]uint16, error) + GetActiveStatus(client *ethclient.Client, id uint16) (bool, error) Jobs(client *ethclient.Client, id uint16) (bindings.StructsJob, error) GetCollectionIdFromIndex(client *ethclient.Client, index uint16) (uint16, error) GetCollectionIdFromLeafId(client *ethclient.Client, leafId uint16) (uint16, error) @@ -296,7 +315,7 @@ type FlagSetUtils interface { } type FileUtils interface { - SaveDataToCommitJsonFile(filePath string, epoch uint32, commitData types.CommitData) error + SaveDataToCommitJsonFile(filePath string, epoch uint32, commitData types.CommitData, commitment [32]byte) error ReadFromCommitJsonFile(filePath string) (types.CommitFileData, error) SaveDataToProposeJsonFile(filePath string, proposeData types.ProposeFileData) error ReadFromProposeJsonFile(filePath string) (types.ProposeFileData, error) @@ -306,9 +325,9 @@ type FileUtils interface { } type GasUtils interface { - GetGasPrice(client *ethclient.Client, config types.Configurations) *big.Int - GetGasLimit(transactionData types.TransactionOptions, txnOpts *bind.TransactOpts) (uint64, error) - IncreaseGasLimitValue(client *ethclient.Client, gasLimit uint64, gasLimitMultiplier float32) (uint64, error) + GetGasPrice(rpcParameters rpc.RPCParameters, config types.Configurations) *big.Int + GetGasLimit(rpcParameters rpc.RPCParameters, transactionData types.TransactionOptions, txnOpts *bind.TransactOpts) (uint64, error) + IncreaseGasLimitValue(rpcParameters rpc.RPCParameters, gasLimit uint64, gasLimitMultiplier float32) (uint64, error) } type UtilsStruct struct{} diff --git a/utils/log.go b/utils/log.go index 8f2dabb3f..5e21da50f 100644 --- a/utils/log.go +++ b/utils/log.go @@ -1,5 +1,7 @@ package utils -import "razor/logger" +import ( + "razor/logger" +) -var log = logger.NewLogger() +var log = logger.GetLogger() diff --git a/utils/math_test.go b/utils/math_test.go index 0772dad53..a3727b0f8 100644 --- a/utils/math_test.go +++ b/utils/math_test.go @@ -258,9 +258,9 @@ func TestCheckAmountAndBalance(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { diff --git a/utils/mocks/abi_utils.go b/utils/mocks/abi_utils.go index fe7e64709..263ca9798 100644 --- a/utils/mocks/abi_utils.go +++ b/utils/mocks/abi_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -23,6 +23,10 @@ func (_m *ABIUtils) Pack(parsedData abi.ABI, name string, args ...interface{}) ( ret := _m.Called(_ca...) var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func(abi.ABI, string, ...interface{}) ([]byte, error)); ok { + return rf(parsedData, name, args...) + } if rf, ok := ret.Get(0).(func(abi.ABI, string, ...interface{}) []byte); ok { r0 = rf(parsedData, name, args...) } else { @@ -31,7 +35,6 @@ func (_m *ABIUtils) Pack(parsedData abi.ABI, name string, args ...interface{}) ( } } - var r1 error if rf, ok := ret.Get(1).(func(abi.ABI, string, ...interface{}) error); ok { r1 = rf(parsedData, name, args...) } else { @@ -46,13 +49,16 @@ func (_m *ABIUtils) Parse(reader io.Reader) (abi.ABI, error) { ret := _m.Called(reader) var r0 abi.ABI + var r1 error + if rf, ok := ret.Get(0).(func(io.Reader) (abi.ABI, error)); ok { + return rf(reader) + } if rf, ok := ret.Get(0).(func(io.Reader) abi.ABI); ok { r0 = rf(reader) } else { r0 = ret.Get(0).(abi.ABI) } - var r1 error if rf, ok := ret.Get(1).(func(io.Reader) error); ok { r1 = rf(reader) } else { @@ -62,13 +68,12 @@ func (_m *ABIUtils) Parse(reader io.Reader) (abi.ABI, error) { return r0, r1 } -type mockConstructorTestingTNewABIUtils interface { +// NewABIUtils creates a new instance of ABIUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewABIUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewABIUtils creates a new instance of ABIUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewABIUtils(t mockConstructorTestingTNewABIUtils) *ABIUtils { +}) *ABIUtils { mock := &ABIUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/asset_manager_utils.go b/utils/mocks/asset_manager_utils.go index 09faa71e6..6714520fa 100644 --- a/utils/mocks/asset_manager_utils.go +++ b/utils/mocks/asset_manager_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -19,6 +19,10 @@ func (_m *AssetManagerUtils) GetActiveCollections(client *ethclient.Client) ([]u ret := _m.Called(client) var r0 []uint16 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) ([]uint16, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) []uint16); ok { r0 = rf(client) } else { @@ -27,7 +31,6 @@ func (_m *AssetManagerUtils) GetActiveCollections(client *ethclient.Client) ([]u } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -37,18 +40,45 @@ func (_m *AssetManagerUtils) GetActiveCollections(client *ethclient.Client) ([]u return r0, r1 } +// GetActiveStatus provides a mock function with given fields: client, id +func (_m *AssetManagerUtils) GetActiveStatus(client *ethclient.Client, id uint16) (bool, error) { + ret := _m.Called(client, id) + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (bool, error)); ok { + return rf(client, id) + } + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) bool); ok { + r0 = rf(client, id) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { + r1 = rf(client, id) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // GetCollection provides a mock function with given fields: client, id func (_m *AssetManagerUtils) GetCollection(client *ethclient.Client, id uint16) (bindings.StructsCollection, error) { ret := _m.Called(client, id) var r0 bindings.StructsCollection + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (bindings.StructsCollection, error)); ok { + return rf(client, id) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) bindings.StructsCollection); ok { r0 = rf(client, id) } else { r0 = ret.Get(0).(bindings.StructsCollection) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { r1 = rf(client, id) } else { @@ -63,13 +93,16 @@ func (_m *AssetManagerUtils) GetCollectionIdFromIndex(client *ethclient.Client, ret := _m.Called(client, index) var r0 uint16 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (uint16, error)); ok { + return rf(client, index) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) uint16); ok { r0 = rf(client, index) } else { r0 = ret.Get(0).(uint16) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { r1 = rf(client, index) } else { @@ -84,13 +117,16 @@ func (_m *AssetManagerUtils) GetCollectionIdFromLeafId(client *ethclient.Client, ret := _m.Called(client, leafId) var r0 uint16 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (uint16, error)); ok { + return rf(client, leafId) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) uint16); ok { r0 = rf(client, leafId) } else { r0 = ret.Get(0).(uint16) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { r1 = rf(client, leafId) } else { @@ -105,13 +141,16 @@ func (_m *AssetManagerUtils) GetJob(client *ethclient.Client, id uint16) (bindin ret := _m.Called(client, id) var r0 bindings.StructsJob + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (bindings.StructsJob, error)); ok { + return rf(client, id) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) bindings.StructsJob); ok { r0 = rf(client, id) } else { r0 = ret.Get(0).(bindings.StructsJob) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { r1 = rf(client, id) } else { @@ -126,13 +165,16 @@ func (_m *AssetManagerUtils) GetLeafIdOfACollection(client *ethclient.Client, co ret := _m.Called(client, collectionId) var r0 uint16 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (uint16, error)); ok { + return rf(client, collectionId) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) uint16); ok { r0 = rf(client, collectionId) } else { r0 = ret.Get(0).(uint16) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { r1 = rf(client, collectionId) } else { @@ -147,13 +189,16 @@ func (_m *AssetManagerUtils) GetNumActiveCollections(client *ethclient.Client) ( ret := _m.Called(client) var r0 uint16 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint16, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) uint16); ok { r0 = rf(client) } else { r0 = ret.Get(0).(uint16) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -168,13 +213,16 @@ func (_m *AssetManagerUtils) GetNumCollections(client *ethclient.Client) (uint16 ret := _m.Called(client) var r0 uint16 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint16, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) uint16); ok { r0 = rf(client) } else { r0 = ret.Get(0).(uint16) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -189,13 +237,16 @@ func (_m *AssetManagerUtils) GetNumJobs(client *ethclient.Client) (uint16, error ret := _m.Called(client) var r0 uint16 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint16, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) uint16); ok { r0 = rf(client) } else { r0 = ret.Get(0).(uint16) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -210,13 +261,16 @@ func (_m *AssetManagerUtils) Jobs(client *ethclient.Client, id uint16) (bindings ret := _m.Called(client, id) var r0 bindings.StructsJob + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (bindings.StructsJob, error)); ok { + return rf(client, id) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) bindings.StructsJob); ok { r0 = rf(client, id) } else { r0 = ret.Get(0).(bindings.StructsJob) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { r1 = rf(client, id) } else { @@ -226,13 +280,12 @@ func (_m *AssetManagerUtils) Jobs(client *ethclient.Client, id uint16) (bindings return r0, r1 } -type mockConstructorTestingTNewAssetManagerUtils interface { +// NewAssetManagerUtils creates a new instance of AssetManagerUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAssetManagerUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewAssetManagerUtils creates a new instance of AssetManagerUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewAssetManagerUtils(t mockConstructorTestingTNewAssetManagerUtils) *AssetManagerUtils { +}) *AssetManagerUtils { mock := &AssetManagerUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/bind_utils.go b/utils/mocks/bind_utils.go index 170527afc..408a36720 100644 --- a/utils/mocks/bind_utils.go +++ b/utils/mocks/bind_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -21,6 +21,10 @@ func (_m *BindUtils) NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainI ret := _m.Called(key, chainID) var r0 *bind.TransactOpts + var r1 error + if rf, ok := ret.Get(0).(func(*ecdsa.PrivateKey, *big.Int) (*bind.TransactOpts, error)); ok { + return rf(key, chainID) + } if rf, ok := ret.Get(0).(func(*ecdsa.PrivateKey, *big.Int) *bind.TransactOpts); ok { r0 = rf(key, chainID) } else { @@ -29,7 +33,6 @@ func (_m *BindUtils) NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainI } } - var r1 error if rf, ok := ret.Get(1).(func(*ecdsa.PrivateKey, *big.Int) error); ok { r1 = rf(key, chainID) } else { @@ -39,13 +42,12 @@ func (_m *BindUtils) NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainI return r0, r1 } -type mockConstructorTestingTNewBindUtils interface { +// NewBindUtils creates a new instance of BindUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewBindUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewBindUtils creates a new instance of BindUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewBindUtils(t mockConstructorTestingTNewBindUtils) *BindUtils { +}) *BindUtils { mock := &BindUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/bindings_utils.go b/utils/mocks/bindings_utils.go index 63e9e0132..bbdfca74d 100644 --- a/utils/mocks/bindings_utils.go +++ b/utils/mocks/bindings_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -21,6 +21,10 @@ func (_m *BindingsUtils) NewBlockManager(address common.Address, client *ethclie ret := _m.Called(address, client) var r0 *bindings.BlockManager + var r1 error + if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) (*bindings.BlockManager, error)); ok { + return rf(address, client) + } if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) *bindings.BlockManager); ok { r0 = rf(address, client) } else { @@ -29,7 +33,6 @@ func (_m *BindingsUtils) NewBlockManager(address common.Address, client *ethclie } } - var r1 error if rf, ok := ret.Get(1).(func(common.Address, *ethclient.Client) error); ok { r1 = rf(address, client) } else { @@ -44,6 +47,10 @@ func (_m *BindingsUtils) NewCollectionManager(address common.Address, client *et ret := _m.Called(address, client) var r0 *bindings.CollectionManager + var r1 error + if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) (*bindings.CollectionManager, error)); ok { + return rf(address, client) + } if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) *bindings.CollectionManager); ok { r0 = rf(address, client) } else { @@ -52,7 +59,6 @@ func (_m *BindingsUtils) NewCollectionManager(address common.Address, client *et } } - var r1 error if rf, ok := ret.Get(1).(func(common.Address, *ethclient.Client) error); ok { r1 = rf(address, client) } else { @@ -67,6 +73,10 @@ func (_m *BindingsUtils) NewRAZOR(address common.Address, client *ethclient.Clie ret := _m.Called(address, client) var r0 *bindings.RAZOR + var r1 error + if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) (*bindings.RAZOR, error)); ok { + return rf(address, client) + } if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) *bindings.RAZOR); ok { r0 = rf(address, client) } else { @@ -75,7 +85,6 @@ func (_m *BindingsUtils) NewRAZOR(address common.Address, client *ethclient.Clie } } - var r1 error if rf, ok := ret.Get(1).(func(common.Address, *ethclient.Client) error); ok { r1 = rf(address, client) } else { @@ -90,6 +99,10 @@ func (_m *BindingsUtils) NewStakeManager(address common.Address, client *ethclie ret := _m.Called(address, client) var r0 *bindings.StakeManager + var r1 error + if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) (*bindings.StakeManager, error)); ok { + return rf(address, client) + } if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) *bindings.StakeManager); ok { r0 = rf(address, client) } else { @@ -98,7 +111,6 @@ func (_m *BindingsUtils) NewStakeManager(address common.Address, client *ethclie } } - var r1 error if rf, ok := ret.Get(1).(func(common.Address, *ethclient.Client) error); ok { r1 = rf(address, client) } else { @@ -113,6 +125,10 @@ func (_m *BindingsUtils) NewStakedToken(address common.Address, client *ethclien ret := _m.Called(address, client) var r0 *bindings.StakedToken + var r1 error + if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) (*bindings.StakedToken, error)); ok { + return rf(address, client) + } if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) *bindings.StakedToken); ok { r0 = rf(address, client) } else { @@ -121,7 +137,6 @@ func (_m *BindingsUtils) NewStakedToken(address common.Address, client *ethclien } } - var r1 error if rf, ok := ret.Get(1).(func(common.Address, *ethclient.Client) error); ok { r1 = rf(address, client) } else { @@ -136,6 +151,10 @@ func (_m *BindingsUtils) NewVoteManager(address common.Address, client *ethclien ret := _m.Called(address, client) var r0 *bindings.VoteManager + var r1 error + if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) (*bindings.VoteManager, error)); ok { + return rf(address, client) + } if rf, ok := ret.Get(0).(func(common.Address, *ethclient.Client) *bindings.VoteManager); ok { r0 = rf(address, client) } else { @@ -144,7 +163,6 @@ func (_m *BindingsUtils) NewVoteManager(address common.Address, client *ethclien } } - var r1 error if rf, ok := ret.Get(1).(func(common.Address, *ethclient.Client) error); ok { r1 = rf(address, client) } else { @@ -154,13 +172,12 @@ func (_m *BindingsUtils) NewVoteManager(address common.Address, client *ethclien return r0, r1 } -type mockConstructorTestingTNewBindingsUtils interface { +// NewBindingsUtils creates a new instance of BindingsUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewBindingsUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewBindingsUtils creates a new instance of BindingsUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewBindingsUtils(t mockConstructorTestingTNewBindingsUtils) *BindingsUtils { +}) *BindingsUtils { mock := &BindingsUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/block_manager_utils.go b/utils/mocks/block_manager_utils.go index 072fb5432..50f70386c 100644 --- a/utils/mocks/block_manager_utils.go +++ b/utils/mocks/block_manager_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -6,9 +6,13 @@ import ( big "math/big" bindings "razor/pkg/bindings" + common "github.com/ethereum/go-ethereum/common" + ethclient "github.com/ethereum/go-ethereum/ethclient" mock "github.com/stretchr/testify/mock" + + types "razor/core/types" ) // BlockManagerUtils is an autogenerated mock type for the BlockManagerUtils type @@ -16,18 +20,45 @@ type BlockManagerUtils struct { mock.Mock } +// Disputes provides a mock function with given fields: client, epoch, address +func (_m *BlockManagerUtils) Disputes(client *ethclient.Client, epoch uint32, address common.Address) (types.DisputesStruct, error) { + ret := _m.Called(client, epoch, address) + + var r0 types.DisputesStruct + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, common.Address) (types.DisputesStruct, error)); ok { + return rf(client, epoch, address) + } + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, common.Address) types.DisputesStruct); ok { + r0 = rf(client, epoch, address) + } else { + r0 = ret.Get(0).(types.DisputesStruct) + } + + if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, common.Address) error); ok { + r1 = rf(client, epoch, address) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // GetBlock provides a mock function with given fields: client, epoch func (_m *BlockManagerUtils) GetBlock(client *ethclient.Client, epoch uint32) (bindings.StructsBlock, error) { ret := _m.Called(client, epoch) var r0 bindings.StructsBlock + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (bindings.StructsBlock, error)); ok { + return rf(client, epoch) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) bindings.StructsBlock); ok { r0 = rf(client, epoch) } else { r0 = ret.Get(0).(bindings.StructsBlock) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { r1 = rf(client, epoch) } else { @@ -42,13 +73,16 @@ func (_m *BlockManagerUtils) GetBlockIndexToBeConfirmed(client *ethclient.Client ret := _m.Called(client) var r0 int8 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (int8, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) int8); ok { r0 = rf(client) } else { r0 = ret.Get(0).(int8) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -58,18 +92,45 @@ func (_m *BlockManagerUtils) GetBlockIndexToBeConfirmed(client *ethclient.Client return r0, r1 } +// GetConfirmedBlocks provides a mock function with given fields: client, epoch +func (_m *BlockManagerUtils) GetConfirmedBlocks(client *ethclient.Client, epoch uint32) (types.ConfirmedBlock, error) { + ret := _m.Called(client, epoch) + + var r0 types.ConfirmedBlock + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (types.ConfirmedBlock, error)); ok { + return rf(client, epoch) + } + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) types.ConfirmedBlock); ok { + r0 = rf(client, epoch) + } else { + r0 = ret.Get(0).(types.ConfirmedBlock) + } + + if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { + r1 = rf(client, epoch) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // GetEpochLastProposed provides a mock function with given fields: client, stakerId func (_m *BlockManagerUtils) GetEpochLastProposed(client *ethclient.Client, stakerId uint32) (uint32, error) { ret := _m.Called(client, stakerId) var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (uint32, error)); ok { + return rf(client, stakerId) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) uint32); ok { r0 = rf(client, stakerId) } else { r0 = ret.Get(0).(uint32) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { r1 = rf(client, stakerId) } else { @@ -84,13 +145,16 @@ func (_m *BlockManagerUtils) GetNumProposedBlocks(client *ethclient.Client, epoc ret := _m.Called(client, epoch) var r0 uint8 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (uint8, error)); ok { + return rf(client, epoch) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) uint8); ok { r0 = rf(client, epoch) } else { r0 = ret.Get(0).(uint8) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { r1 = rf(client, epoch) } else { @@ -105,13 +169,16 @@ func (_m *BlockManagerUtils) GetProposedBlock(client *ethclient.Client, epoch ui ret := _m.Called(client, epoch, proposedBlock) var r0 bindings.StructsBlock + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32) (bindings.StructsBlock, error)); ok { + return rf(client, epoch, proposedBlock) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32) bindings.StructsBlock); ok { r0 = rf(client, epoch, proposedBlock) } else { r0 = ret.Get(0).(bindings.StructsBlock) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, uint32) error); ok { r1 = rf(client, epoch, proposedBlock) } else { @@ -126,13 +193,16 @@ func (_m *BlockManagerUtils) MaxAltBlocks(client *ethclient.Client) (uint8, erro ret := _m.Called(client) var r0 uint8 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint8, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) uint8); ok { r0 = rf(client) } else { r0 = ret.Get(0).(uint8) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -147,6 +217,10 @@ func (_m *BlockManagerUtils) MinStake(client *ethclient.Client) (*big.Int, error ret := _m.Called(client) var r0 *big.Int + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (*big.Int, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) *big.Int); ok { r0 = rf(client) } else { @@ -155,7 +229,6 @@ func (_m *BlockManagerUtils) MinStake(client *ethclient.Client) (*big.Int, error } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -170,13 +243,16 @@ func (_m *BlockManagerUtils) SortedProposedBlockIds(client *ethclient.Client, ar ret := _m.Called(client, arg0, arg1) var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, *big.Int) (uint32, error)); ok { + return rf(client, arg0, arg1) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, *big.Int) uint32); ok { r0 = rf(client, arg0, arg1) } else { r0 = ret.Get(0).(uint32) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, *big.Int) error); ok { r1 = rf(client, arg0, arg1) } else { @@ -191,13 +267,16 @@ func (_m *BlockManagerUtils) StateBuffer(client *ethclient.Client) (uint8, error ret := _m.Called(client) var r0 uint8 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint8, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) uint8); ok { r0 = rf(client) } else { r0 = ret.Get(0).(uint8) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -207,13 +286,12 @@ func (_m *BlockManagerUtils) StateBuffer(client *ethclient.Client) (uint8, error return r0, r1 } -type mockConstructorTestingTNewBlockManagerUtils interface { +// NewBlockManagerUtils creates a new instance of BlockManagerUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewBlockManagerUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewBlockManagerUtils creates a new instance of BlockManagerUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewBlockManagerUtils(t mockConstructorTestingTNewBlockManagerUtils) *BlockManagerUtils { +}) *BlockManagerUtils { mock := &BlockManagerUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/client_utils.go b/utils/mocks/client_utils.go index 73cdfe6ac..ecde0c240 100644 --- a/utils/mocks/client_utils.go +++ b/utils/mocks/client_utils.go @@ -4,6 +4,7 @@ package mocks import ( big "math/big" + RPC "razor/rpc" abi "github.com/ethereum/go-ethereum/accounts/abi" @@ -53,25 +54,25 @@ func (_m *ClientUtils) BalanceAt(client *ethclient.Client, ctx context.Context, return r0, r1 } -// BalanceAtWithRetry provides a mock function with given fields: client, account -func (_m *ClientUtils) BalanceAtWithRetry(client *ethclient.Client, account common.Address) (*big.Int, error) { - ret := _m.Called(client, account) +// BalanceAtWithRetry provides a mock function with given fields: rpcParameters, account +func (_m *ClientUtils) BalanceAtWithRetry(rpcParameters RPC.RPCParameters, account common.Address) (*big.Int, error) { + ret := _m.Called(rpcParameters, account) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address) (*big.Int, error)); ok { - return rf(client, account) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, common.Address) (*big.Int, error)); ok { + return rf(rpcParameters, account) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address) *big.Int); ok { - r0 = rf(client, account) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, common.Address) *big.Int); ok { + r0 = rf(rpcParameters, account) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, common.Address) error); ok { - r1 = rf(client, account) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, common.Address) error); ok { + r1 = rf(rpcParameters, account) } else { r1 = ret.Error(1) } @@ -79,25 +80,25 @@ func (_m *ClientUtils) BalanceAtWithRetry(client *ethclient.Client, account comm return r0, r1 } -// BatchCall provides a mock function with given fields: client, contractABI, contractAddress, methodName, args -func (_m *ClientUtils) BatchCall(client *ethclient.Client, contractABI *abi.ABI, contractAddress string, methodName string, args [][]interface{}) ([][]interface{}, error) { - ret := _m.Called(client, contractABI, contractAddress, methodName, args) +// BatchCall provides a mock function with given fields: rpcParameters, contractABI, contractAddress, methodName, args +func (_m *ClientUtils) BatchCall(rpcParameters RPC.RPCParameters, contractABI *abi.ABI, contractAddress string, methodName string, args [][]interface{}) ([][]interface{}, error) { + ret := _m.Called(rpcParameters, contractABI, contractAddress, methodName, args) var r0 [][]interface{} var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, *abi.ABI, string, string, [][]interface{}) ([][]interface{}, error)); ok { - return rf(client, contractABI, contractAddress, methodName, args) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *abi.ABI, string, string, [][]interface{}) ([][]interface{}, error)); ok { + return rf(rpcParameters, contractABI, contractAddress, methodName, args) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, *abi.ABI, string, string, [][]interface{}) [][]interface{}); ok { - r0 = rf(client, contractABI, contractAddress, methodName, args) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *abi.ABI, string, string, [][]interface{}) [][]interface{}); ok { + r0 = rf(rpcParameters, contractABI, contractAddress, methodName, args) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([][]interface{}) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, *abi.ABI, string, string, [][]interface{}) error); ok { - r1 = rf(client, contractABI, contractAddress, methodName, args) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, *abi.ABI, string, string, [][]interface{}) error); ok { + r1 = rf(rpcParameters, contractABI, contractAddress, methodName, args) } else { r1 = ret.Error(1) } @@ -155,23 +156,23 @@ func (_m *ClientUtils) EstimateGas(client *ethclient.Client, ctx context.Context return r0, r1 } -// EstimateGasWithRetry provides a mock function with given fields: client, message -func (_m *ClientUtils) EstimateGasWithRetry(client *ethclient.Client, message ethereum.CallMsg) (uint64, error) { - ret := _m.Called(client, message) +// EstimateGasWithRetry provides a mock function with given fields: rpcParameters, message +func (_m *ClientUtils) EstimateGasWithRetry(rpcParameters RPC.RPCParameters, message ethereum.CallMsg) (uint64, error) { + ret := _m.Called(rpcParameters, message) var r0 uint64 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, ethereum.CallMsg) (uint64, error)); ok { - return rf(client, message) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, ethereum.CallMsg) (uint64, error)); ok { + return rf(rpcParameters, message) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, ethereum.CallMsg) uint64); ok { - r0 = rf(client, message) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, ethereum.CallMsg) uint64); ok { + r0 = rf(rpcParameters, message) } else { r0 = ret.Get(0).(uint64) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, ethereum.CallMsg) error); ok { - r1 = rf(client, message) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, ethereum.CallMsg) error); ok { + r1 = rf(rpcParameters, message) } else { r1 = ret.Error(1) } @@ -205,25 +206,25 @@ func (_m *ClientUtils) FilterLogs(client *ethclient.Client, ctx context.Context, return r0, r1 } -// FilterLogsWithRetry provides a mock function with given fields: client, query -func (_m *ClientUtils) FilterLogsWithRetry(client *ethclient.Client, query ethereum.FilterQuery) ([]types.Log, error) { - ret := _m.Called(client, query) +// FilterLogsWithRetry provides a mock function with given fields: rpcParameters, query +func (_m *ClientUtils) FilterLogsWithRetry(rpcParameters RPC.RPCParameters, query ethereum.FilterQuery) ([]types.Log, error) { + ret := _m.Called(rpcParameters, query) var r0 []types.Log var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, ethereum.FilterQuery) ([]types.Log, error)); ok { - return rf(client, query) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, ethereum.FilterQuery) ([]types.Log, error)); ok { + return rf(rpcParameters, query) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, ethereum.FilterQuery) []types.Log); ok { - r0 = rf(client, query) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, ethereum.FilterQuery) []types.Log); ok { + r0 = rf(rpcParameters, query) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]types.Log) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, ethereum.FilterQuery) error); ok { - r1 = rf(client, query) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, ethereum.FilterQuery) error); ok { + r1 = rf(rpcParameters, query) } else { r1 = ret.Error(1) } @@ -231,25 +232,25 @@ func (_m *ClientUtils) FilterLogsWithRetry(client *ethclient.Client, query ether return r0, r1 } -// GetLatestBlockWithRetry provides a mock function with given fields: client -func (_m *ClientUtils) GetLatestBlockWithRetry(client *ethclient.Client) (*types.Header, error) { - ret := _m.Called(client) +// GetBlockByNumberWithRetry provides a mock function with given fields: rpcParameters, blockNumber +func (_m *ClientUtils) GetBlockByNumberWithRetry(rpcParameters RPC.RPCParameters, blockNumber *big.Int) (*types.Header, error) { + ret := _m.Called(rpcParameters, blockNumber) var r0 *types.Header var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (*types.Header, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *big.Int) (*types.Header, error)); ok { + return rf(rpcParameters, blockNumber) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) *types.Header); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, *big.Int) *types.Header); ok { + r0 = rf(rpcParameters, blockNumber) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*types.Header) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, *big.Int) error); ok { + r1 = rf(rpcParameters, blockNumber) } else { r1 = ret.Error(1) } @@ -257,23 +258,49 @@ func (_m *ClientUtils) GetLatestBlockWithRetry(client *ethclient.Client) (*types return r0, r1 } -// GetNonceAtWithRetry provides a mock function with given fields: client, accountAddress -func (_m *ClientUtils) GetNonceAtWithRetry(client *ethclient.Client, accountAddress common.Address) (uint64, error) { - ret := _m.Called(client, accountAddress) +// GetLatestBlockWithRetry provides a mock function with given fields: rpcParameters +func (_m *ClientUtils) GetLatestBlockWithRetry(rpcParameters RPC.RPCParameters) (*types.Header, error) { + ret := _m.Called(rpcParameters) + + var r0 *types.Header + var r1 error + if rf, ok := ret.Get(0).(func(RPC.RPCParameters) (*types.Header, error)); ok { + return rf(rpcParameters) + } + if rf, ok := ret.Get(0).(func(RPC.RPCParameters) *types.Header); ok { + r0 = rf(rpcParameters) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.Header) + } + } + + if rf, ok := ret.Get(1).(func(RPC.RPCParameters) error); ok { + r1 = rf(rpcParameters) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetNonceAtWithRetry provides a mock function with given fields: rpcParameters, accountAddress +func (_m *ClientUtils) GetNonceAtWithRetry(rpcParameters RPC.RPCParameters, accountAddress common.Address) (uint64, error) { + ret := _m.Called(rpcParameters, accountAddress) var r0 uint64 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address) (uint64, error)); ok { - return rf(client, accountAddress) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, common.Address) (uint64, error)); ok { + return rf(rpcParameters, accountAddress) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address) uint64); ok { - r0 = rf(client, accountAddress) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, common.Address) uint64); ok { + r0 = rf(rpcParameters, accountAddress) } else { r0 = ret.Get(0).(uint64) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, common.Address) error); ok { - r1 = rf(client, accountAddress) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, common.Address) error); ok { + r1 = rf(rpcParameters, accountAddress) } else { r1 = ret.Error(1) } @@ -331,13 +358,13 @@ func (_m *ClientUtils) NonceAt(client *ethclient.Client, ctx context.Context, ac return r0, r1 } -// PerformBatchCall provides a mock function with given fields: client, calls -func (_m *ClientUtils) PerformBatchCall(client *ethclient.Client, calls []rpc.BatchElem) error { - ret := _m.Called(client, calls) +// PerformBatchCall provides a mock function with given fields: rpcParameters, calls +func (_m *ClientUtils) PerformBatchCall(rpcParameters RPC.RPCParameters, calls []rpc.BatchElem) error { + ret := _m.Called(rpcParameters, calls) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, []rpc.BatchElem) error); ok { - r0 = rf(client, calls) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, []rpc.BatchElem) error); ok { + r0 = rf(rpcParameters, calls) } else { r0 = ret.Error(0) } @@ -371,25 +398,25 @@ func (_m *ClientUtils) SuggestGasPrice(client *ethclient.Client, ctx context.Con return r0, r1 } -// SuggestGasPriceWithRetry provides a mock function with given fields: client -func (_m *ClientUtils) SuggestGasPriceWithRetry(client *ethclient.Client) (*big.Int, error) { - ret := _m.Called(client) +// SuggestGasPriceWithRetry provides a mock function with given fields: rpcParameters +func (_m *ClientUtils) SuggestGasPriceWithRetry(rpcParameters RPC.RPCParameters) (*big.Int, error) { + ret := _m.Called(rpcParameters) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (*big.Int, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters) (*big.Int, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) *big.Int); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters) *big.Int); ok { + r0 = rf(rpcParameters) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } diff --git a/utils/mocks/coin_utils.go b/utils/mocks/coin_utils.go index b885937b7..08b05174d 100644 --- a/utils/mocks/coin_utils.go +++ b/utils/mocks/coin_utils.go @@ -1,14 +1,12 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks import ( big "math/big" - bindings "razor/pkg/bindings" - - bind "github.com/ethereum/go-ethereum/accounts/abi/bind" common "github.com/ethereum/go-ethereum/common" + ethclient "github.com/ethereum/go-ethereum/ethclient" mock "github.com/stretchr/testify/mock" ) @@ -18,22 +16,25 @@ type CoinUtils struct { mock.Mock } -// BalanceOf provides a mock function with given fields: erc20Contract, opts, account -func (_m *CoinUtils) BalanceOf(erc20Contract *bindings.RAZOR, opts *bind.CallOpts, account common.Address) (*big.Int, error) { - ret := _m.Called(erc20Contract, opts, account) +// Allowance provides a mock function with given fields: client, owner, spender +func (_m *CoinUtils) Allowance(client *ethclient.Client, owner common.Address, spender common.Address) (*big.Int, error) { + ret := _m.Called(client, owner, spender) var r0 *big.Int - if rf, ok := ret.Get(0).(func(*bindings.RAZOR, *bind.CallOpts, common.Address) *big.Int); ok { - r0 = rf(erc20Contract, opts, account) + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address, common.Address) (*big.Int, error)); ok { + return rf(client, owner, spender) + } + if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address, common.Address) *big.Int); ok { + r0 = rf(client, owner, spender) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - var r1 error - if rf, ok := ret.Get(1).(func(*bindings.RAZOR, *bind.CallOpts, common.Address) error); ok { - r1 = rf(erc20Contract, opts, account) + if rf, ok := ret.Get(1).(func(*ethclient.Client, common.Address, common.Address) error); ok { + r1 = rf(client, owner, spender) } else { r1 = ret.Error(1) } @@ -41,13 +42,38 @@ func (_m *CoinUtils) BalanceOf(erc20Contract *bindings.RAZOR, opts *bind.CallOpt return r0, r1 } -type mockConstructorTestingTNewCoinUtils interface { - mock.TestingT - Cleanup(func()) +// BalanceOf provides a mock function with given fields: client, account +func (_m *CoinUtils) BalanceOf(client *ethclient.Client, account common.Address) (*big.Int, error) { + ret := _m.Called(client, account) + + var r0 *big.Int + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address) (*big.Int, error)); ok { + return rf(client, account) + } + if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address) *big.Int); ok { + r0 = rf(client, account) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*big.Int) + } + } + + if rf, ok := ret.Get(1).(func(*ethclient.Client, common.Address) error); ok { + r1 = rf(client, account) + } else { + r1 = ret.Error(1) + } + + return r0, r1 } // NewCoinUtils creates a new instance of CoinUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewCoinUtils(t mockConstructorTestingTNewCoinUtils) *CoinUtils { +// The first argument is typically a *testing.T value. +func NewCoinUtils(t interface { + mock.TestingT + Cleanup(func()) +}) *CoinUtils { mock := &CoinUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/eth_client_utils.go b/utils/mocks/eth_client_utils.go index 3ca9afc90..d1d0dfb19 100644 --- a/utils/mocks/eth_client_utils.go +++ b/utils/mocks/eth_client_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -17,6 +17,10 @@ func (_m *EthClientUtils) Dial(rawurl string) (*ethclient.Client, error) { ret := _m.Called(rawurl) var r0 *ethclient.Client + var r1 error + if rf, ok := ret.Get(0).(func(string) (*ethclient.Client, error)); ok { + return rf(rawurl) + } if rf, ok := ret.Get(0).(func(string) *ethclient.Client); ok { r0 = rf(rawurl) } else { @@ -25,7 +29,6 @@ func (_m *EthClientUtils) Dial(rawurl string) (*ethclient.Client, error) { } } - var r1 error if rf, ok := ret.Get(1).(func(string) error); ok { r1 = rf(rawurl) } else { @@ -35,13 +38,12 @@ func (_m *EthClientUtils) Dial(rawurl string) (*ethclient.Client, error) { return r0, r1 } -type mockConstructorTestingTNewEthClientUtils interface { +// NewEthClientUtils creates a new instance of EthClientUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewEthClientUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewEthClientUtils creates a new instance of EthClientUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewEthClientUtils(t mockConstructorTestingTNewEthClientUtils) *EthClientUtils { +}) *EthClientUtils { mock := &EthClientUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/file_utils.go b/utils/mocks/file_utils.go index d107eadac..56c64175b 100644 --- a/utils/mocks/file_utils.go +++ b/utils/mocks/file_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -24,13 +24,16 @@ func (_m *FileUtils) ReadFromCommitJsonFile(filePath string) (types.CommitFileDa ret := _m.Called(filePath) var r0 types.CommitFileData + var r1 error + if rf, ok := ret.Get(0).(func(string) (types.CommitFileData, error)); ok { + return rf(filePath) + } if rf, ok := ret.Get(0).(func(string) types.CommitFileData); ok { r0 = rf(filePath) } else { r0 = ret.Get(0).(types.CommitFileData) } - var r1 error if rf, ok := ret.Get(1).(func(string) error); ok { r1 = rf(filePath) } else { @@ -45,13 +48,16 @@ func (_m *FileUtils) ReadFromDisputeJsonFile(filePath string) (types.DisputeFile ret := _m.Called(filePath) var r0 types.DisputeFileData + var r1 error + if rf, ok := ret.Get(0).(func(string) (types.DisputeFileData, error)); ok { + return rf(filePath) + } if rf, ok := ret.Get(0).(func(string) types.DisputeFileData); ok { r0 = rf(filePath) } else { r0 = ret.Get(0).(types.DisputeFileData) } - var r1 error if rf, ok := ret.Get(1).(func(string) error); ok { r1 = rf(filePath) } else { @@ -66,13 +72,16 @@ func (_m *FileUtils) ReadFromProposeJsonFile(filePath string) (types.ProposeFile ret := _m.Called(filePath) var r0 types.ProposeFileData + var r1 error + if rf, ok := ret.Get(0).(func(string) (types.ProposeFileData, error)); ok { + return rf(filePath) + } if rf, ok := ret.Get(0).(func(string) types.ProposeFileData); ok { r0 = rf(filePath) } else { r0 = ret.Get(0).(types.ProposeFileData) } - var r1 error if rf, ok := ret.Get(1).(func(string) error); ok { r1 = rf(filePath) } else { @@ -82,13 +91,13 @@ func (_m *FileUtils) ReadFromProposeJsonFile(filePath string) (types.ProposeFile return r0, r1 } -// SaveDataToCommitJsonFile provides a mock function with given fields: filePath, epoch, commitData -func (_m *FileUtils) SaveDataToCommitJsonFile(filePath string, epoch uint32, commitData types.CommitData) error { - ret := _m.Called(filePath, epoch, commitData) +// SaveDataToCommitJsonFile provides a mock function with given fields: filePath, epoch, commitData, commitment +func (_m *FileUtils) SaveDataToCommitJsonFile(filePath string, epoch uint32, commitData types.CommitData, commitment [32]byte) error { + ret := _m.Called(filePath, epoch, commitData, commitment) var r0 error - if rf, ok := ret.Get(0).(func(string, uint32, types.CommitData) error); ok { - r0 = rf(filePath, epoch, commitData) + if rf, ok := ret.Get(0).(func(string, uint32, types.CommitData, [32]byte) error); ok { + r0 = rf(filePath, epoch, commitData, commitment) } else { r0 = ret.Error(0) } @@ -124,13 +133,12 @@ func (_m *FileUtils) SaveDataToProposeJsonFile(filePath string, proposeData type return r0 } -type mockConstructorTestingTNewFileUtils interface { +// NewFileUtils creates a new instance of FileUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewFileUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewFileUtils creates a new instance of FileUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewFileUtils(t mockConstructorTestingTNewFileUtils) *FileUtils { +}) *FileUtils { mock := &FileUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/flag_set_utils.go b/utils/mocks/flag_set_utils.go index 1887c99aa..796caec4b 100644 --- a/utils/mocks/flag_set_utils.go +++ b/utils/mocks/flag_set_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -17,13 +17,16 @@ func (_m *FlagSetUtils) GetLogFileName(flagSet *pflag.FlagSet) (string, error) { ret := _m.Called(flagSet) var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(*pflag.FlagSet) (string, error)); ok { + return rf(flagSet) + } if rf, ok := ret.Get(0).(func(*pflag.FlagSet) string); ok { r0 = rf(flagSet) } else { r0 = ret.Get(0).(string) } - var r1 error if rf, ok := ret.Get(1).(func(*pflag.FlagSet) error); ok { r1 = rf(flagSet) } else { @@ -33,13 +36,12 @@ func (_m *FlagSetUtils) GetLogFileName(flagSet *pflag.FlagSet) (string, error) { return r0, r1 } -type mockConstructorTestingTNewFlagSetUtils interface { +// NewFlagSetUtils creates a new instance of FlagSetUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewFlagSetUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewFlagSetUtils creates a new instance of FlagSetUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewFlagSetUtils(t mockConstructorTestingTNewFlagSetUtils) *FlagSetUtils { +}) *FlagSetUtils { mock := &FlagSetUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/gas_utils.go b/utils/mocks/gas_utils.go index 59351797c..b3085c7db 100644 --- a/utils/mocks/gas_utils.go +++ b/utils/mocks/gas_utils.go @@ -1,13 +1,12 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks import ( big "math/big" + RPC "razor/rpc" bind "github.com/ethereum/go-ethereum/accounts/abi/bind" - ethclient "github.com/ethereum/go-ethereum/ethclient" - mock "github.com/stretchr/testify/mock" types "razor/core/types" @@ -18,20 +17,23 @@ type GasUtils struct { mock.Mock } -// GetGasLimit provides a mock function with given fields: transactionData, txnOpts -func (_m *GasUtils) GetGasLimit(transactionData types.TransactionOptions, txnOpts *bind.TransactOpts) (uint64, error) { - ret := _m.Called(transactionData, txnOpts) +// GetGasLimit provides a mock function with given fields: rpcParameters, transactionData, txnOpts +func (_m *GasUtils) GetGasLimit(rpcParameters RPC.RPCParameters, transactionData types.TransactionOptions, txnOpts *bind.TransactOpts) (uint64, error) { + ret := _m.Called(rpcParameters, transactionData, txnOpts) var r0 uint64 - if rf, ok := ret.Get(0).(func(types.TransactionOptions, *bind.TransactOpts) uint64); ok { - r0 = rf(transactionData, txnOpts) + var r1 error + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions, *bind.TransactOpts) (uint64, error)); ok { + return rf(rpcParameters, transactionData, txnOpts) + } + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.TransactionOptions, *bind.TransactOpts) uint64); ok { + r0 = rf(rpcParameters, transactionData, txnOpts) } else { r0 = ret.Get(0).(uint64) } - var r1 error - if rf, ok := ret.Get(1).(func(types.TransactionOptions, *bind.TransactOpts) error); ok { - r1 = rf(transactionData, txnOpts) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, types.TransactionOptions, *bind.TransactOpts) error); ok { + r1 = rf(rpcParameters, transactionData, txnOpts) } else { r1 = ret.Error(1) } @@ -39,13 +41,13 @@ func (_m *GasUtils) GetGasLimit(transactionData types.TransactionOptions, txnOpt return r0, r1 } -// GetGasPrice provides a mock function with given fields: client, config -func (_m *GasUtils) GetGasPrice(client *ethclient.Client, config types.Configurations) *big.Int { - ret := _m.Called(client, config) +// GetGasPrice provides a mock function with given fields: rpcParameters, config +func (_m *GasUtils) GetGasPrice(rpcParameters RPC.RPCParameters, config types.Configurations) *big.Int { + ret := _m.Called(rpcParameters, config) var r0 *big.Int - if rf, ok := ret.Get(0).(func(*ethclient.Client, types.Configurations) *big.Int); ok { - r0 = rf(client, config) + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, types.Configurations) *big.Int); ok { + r0 = rf(rpcParameters, config) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) @@ -55,20 +57,23 @@ func (_m *GasUtils) GetGasPrice(client *ethclient.Client, config types.Configura return r0 } -// IncreaseGasLimitValue provides a mock function with given fields: client, gasLimit, gasLimitMultiplier -func (_m *GasUtils) IncreaseGasLimitValue(client *ethclient.Client, gasLimit uint64, gasLimitMultiplier float32) (uint64, error) { - ret := _m.Called(client, gasLimit, gasLimitMultiplier) +// IncreaseGasLimitValue provides a mock function with given fields: rpcParameters, gasLimit, gasLimitMultiplier +func (_m *GasUtils) IncreaseGasLimitValue(rpcParameters RPC.RPCParameters, gasLimit uint64, gasLimitMultiplier float32) (uint64, error) { + ret := _m.Called(rpcParameters, gasLimit, gasLimitMultiplier) var r0 uint64 - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint64, float32) uint64); ok { - r0 = rf(client, gasLimit, gasLimitMultiplier) + var r1 error + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint64, float32) (uint64, error)); ok { + return rf(rpcParameters, gasLimit, gasLimitMultiplier) + } + if rf, ok := ret.Get(0).(func(RPC.RPCParameters, uint64, float32) uint64); ok { + r0 = rf(rpcParameters, gasLimit, gasLimitMultiplier) } else { r0 = ret.Get(0).(uint64) } - var r1 error - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint64, float32) error); ok { - r1 = rf(client, gasLimit, gasLimitMultiplier) + if rf, ok := ret.Get(1).(func(RPC.RPCParameters, uint64, float32) error); ok { + r1 = rf(rpcParameters, gasLimit, gasLimitMultiplier) } else { r1 = ret.Error(1) } @@ -76,13 +81,12 @@ func (_m *GasUtils) IncreaseGasLimitValue(client *ethclient.Client, gasLimit uin return r0, r1 } -type mockConstructorTestingTNewGasUtils interface { +// NewGasUtils creates a new instance of GasUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewGasUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewGasUtils creates a new instance of GasUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewGasUtils(t mockConstructorTestingTNewGasUtils) *GasUtils { +}) *GasUtils { mock := &GasUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/io_utils.go b/utils/mocks/io_utils.go index 0515dfe46..53abf8243 100644 --- a/utils/mocks/io_utils.go +++ b/utils/mocks/io_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -18,6 +18,10 @@ func (_m *IOUtils) ReadAll(body io.ReadCloser) ([]byte, error) { ret := _m.Called(body) var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func(io.ReadCloser) ([]byte, error)); ok { + return rf(body) + } if rf, ok := ret.Get(0).(func(io.ReadCloser) []byte); ok { r0 = rf(body) } else { @@ -26,7 +30,6 @@ func (_m *IOUtils) ReadAll(body io.ReadCloser) ([]byte, error) { } } - var r1 error if rf, ok := ret.Get(1).(func(io.ReadCloser) error); ok { r1 = rf(body) } else { @@ -36,13 +39,12 @@ func (_m *IOUtils) ReadAll(body io.ReadCloser) ([]byte, error) { return r0, r1 } -type mockConstructorTestingTNewIOUtils interface { +// NewIOUtils creates a new instance of IOUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewIOUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewIOUtils creates a new instance of IOUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewIOUtils(t mockConstructorTestingTNewIOUtils) *IOUtils { +}) *IOUtils { mock := &IOUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/json_utils.go b/utils/mocks/json_utils.go index d679371cf..0ed546611 100644 --- a/utils/mocks/json_utils.go +++ b/utils/mocks/json_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -14,6 +14,10 @@ func (_m *JsonUtils) Marshal(v interface{}) ([]byte, error) { ret := _m.Called(v) var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func(interface{}) ([]byte, error)); ok { + return rf(v) + } if rf, ok := ret.Get(0).(func(interface{}) []byte); ok { r0 = rf(v) } else { @@ -22,7 +26,6 @@ func (_m *JsonUtils) Marshal(v interface{}) ([]byte, error) { } } - var r1 error if rf, ok := ret.Get(1).(func(interface{}) error); ok { r1 = rf(v) } else { @@ -46,13 +49,12 @@ func (_m *JsonUtils) Unmarshal(data []byte, v interface{}) error { return r0 } -type mockConstructorTestingTNewJsonUtils interface { +// NewJsonUtils creates a new instance of JsonUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewJsonUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewJsonUtils creates a new instance of JsonUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewJsonUtils(t mockConstructorTestingTNewJsonUtils) *JsonUtils { +}) *JsonUtils { mock := &JsonUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/merkle_tree_interface.go b/utils/mocks/merkle_tree_interface.go index 60b8654f8..04793ec8b 100644 --- a/utils/mocks/merkle_tree_interface.go +++ b/utils/mocks/merkle_tree_interface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -18,6 +18,10 @@ func (_m *MerkleTreeInterface) CreateMerkle(values []*big.Int) ([][][]byte, erro ret := _m.Called(values) var r0 [][][]byte + var r1 error + if rf, ok := ret.Get(0).(func([]*big.Int) ([][][]byte, error)); ok { + return rf(values) + } if rf, ok := ret.Get(0).(func([]*big.Int) [][][]byte); ok { r0 = rf(values) } else { @@ -26,7 +30,6 @@ func (_m *MerkleTreeInterface) CreateMerkle(values []*big.Int) ([][][]byte, erro } } - var r1 error if rf, ok := ret.Get(1).(func([]*big.Int) error); ok { r1 = rf(values) } else { @@ -41,6 +44,10 @@ func (_m *MerkleTreeInterface) GetMerkleRoot(tree [][][]byte) ([32]byte, error) ret := _m.Called(tree) var r0 [32]byte + var r1 error + if rf, ok := ret.Get(0).(func([][][]byte) ([32]byte, error)); ok { + return rf(tree) + } if rf, ok := ret.Get(0).(func([][][]byte) [32]byte); ok { r0 = rf(tree) } else { @@ -49,7 +56,6 @@ func (_m *MerkleTreeInterface) GetMerkleRoot(tree [][][]byte) ([32]byte, error) } } - var r1 error if rf, ok := ret.Get(1).(func([][][]byte) error); ok { r1 = rf(tree) } else { @@ -75,13 +81,12 @@ func (_m *MerkleTreeInterface) GetProofPath(tree [][][]byte, assetId uint16) [][ return r0 } -type mockConstructorTestingTNewMerkleTreeInterface interface { +// NewMerkleTreeInterface creates a new instance of MerkleTreeInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMerkleTreeInterface(t interface { mock.TestingT Cleanup(func()) -} - -// NewMerkleTreeInterface creates a new instance of MerkleTreeInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMerkleTreeInterface(t mockConstructorTestingTNewMerkleTreeInterface) *MerkleTreeInterface { +}) *MerkleTreeInterface { mock := &MerkleTreeInterface{} mock.Mock.Test(t) diff --git a/utils/mocks/os_utils.go b/utils/mocks/os_utils.go index 4d1e4fe49..d9a0da04f 100644 --- a/utils/mocks/os_utils.go +++ b/utils/mocks/os_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -19,6 +19,10 @@ func (_m *OSUtils) Open(name string) (*os.File, error) { ret := _m.Called(name) var r0 *os.File + var r1 error + if rf, ok := ret.Get(0).(func(string) (*os.File, error)); ok { + return rf(name) + } if rf, ok := ret.Get(0).(func(string) *os.File); ok { r0 = rf(name) } else { @@ -27,7 +31,6 @@ func (_m *OSUtils) Open(name string) (*os.File, error) { } } - var r1 error if rf, ok := ret.Get(1).(func(string) error); ok { r1 = rf(name) } else { @@ -42,6 +45,10 @@ func (_m *OSUtils) OpenFile(name string, flag int, perm fs.FileMode) (*os.File, ret := _m.Called(name, flag, perm) var r0 *os.File + var r1 error + if rf, ok := ret.Get(0).(func(string, int, fs.FileMode) (*os.File, error)); ok { + return rf(name, flag, perm) + } if rf, ok := ret.Get(0).(func(string, int, fs.FileMode) *os.File); ok { r0 = rf(name, flag, perm) } else { @@ -50,7 +57,6 @@ func (_m *OSUtils) OpenFile(name string, flag int, perm fs.FileMode) (*os.File, } } - var r1 error if rf, ok := ret.Get(1).(func(string, int, fs.FileMode) error); ok { r1 = rf(name, flag, perm) } else { @@ -65,6 +71,10 @@ func (_m *OSUtils) ReadFile(filename string) ([]byte, error) { ret := _m.Called(filename) var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func(string) ([]byte, error)); ok { + return rf(filename) + } if rf, ok := ret.Get(0).(func(string) []byte); ok { r0 = rf(filename) } else { @@ -73,7 +83,6 @@ func (_m *OSUtils) ReadFile(filename string) ([]byte, error) { } } - var r1 error if rf, ok := ret.Get(1).(func(string) error); ok { r1 = rf(filename) } else { @@ -97,13 +106,12 @@ func (_m *OSUtils) WriteFile(name string, data []byte, perm fs.FileMode) error { return r0 } -type mockConstructorTestingTNewOSUtils interface { +// NewOSUtils creates a new instance of OSUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewOSUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewOSUtils creates a new instance of OSUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewOSUtils(t mockConstructorTestingTNewOSUtils) *OSUtils { +}) *OSUtils { mock := &OSUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/path_utils.go b/utils/mocks/path_utils.go index a08d4489d..876a3bcac 100644 --- a/utils/mocks/path_utils.go +++ b/utils/mocks/path_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -14,13 +14,16 @@ func (_m *PathUtils) GetDefaultPath() (string, error) { ret := _m.Called() var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() } else { r0 = ret.Get(0).(string) } - var r1 error if rf, ok := ret.Get(1).(func() error); ok { r1 = rf() } else { @@ -35,13 +38,16 @@ func (_m *PathUtils) GetJobFilePath() (string, error) { ret := _m.Called() var r0 string + var r1 error + if rf, ok := ret.Get(0).(func() (string, error)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() } else { r0 = ret.Get(0).(string) } - var r1 error if rf, ok := ret.Get(1).(func() error); ok { r1 = rf() } else { @@ -51,13 +57,12 @@ func (_m *PathUtils) GetJobFilePath() (string, error) { return r0, r1 } -type mockConstructorTestingTNewPathUtils interface { +// NewPathUtils creates a new instance of PathUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewPathUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewPathUtils creates a new instance of PathUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewPathUtils(t mockConstructorTestingTNewPathUtils) *PathUtils { +}) *PathUtils { mock := &PathUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/retry_utils.go b/utils/mocks/retry_utils.go index aa02f7b82..956abb7ac 100644 --- a/utils/mocks/retry_utils.go +++ b/utils/mocks/retry_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -28,13 +28,12 @@ func (_m *RetryUtils) RetryAttempts(numberOfAttempts uint) retry.Option { return r0 } -type mockConstructorTestingTNewRetryUtils interface { +// NewRetryUtils creates a new instance of RetryUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRetryUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewRetryUtils creates a new instance of RetryUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewRetryUtils(t mockConstructorTestingTNewRetryUtils) *RetryUtils { +}) *RetryUtils { mock := &RetryUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/stake_manager_utils.go b/utils/mocks/stake_manager_utils.go index 57a42b7e4..ac9530288 100644 --- a/utils/mocks/stake_manager_utils.go +++ b/utils/mocks/stake_manager_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -25,13 +25,16 @@ func (_m *StakeManagerUtils) EpochLimitForUpdateCommission(client *ethclient.Cli ret := _m.Called(client) var r0 uint16 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint16, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) uint16); ok { r0 = rf(client) } else { r0 = ret.Get(0).(uint16) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -41,18 +44,69 @@ func (_m *StakeManagerUtils) EpochLimitForUpdateCommission(client *ethclient.Cli return r0, r1 } +// GetBountyLock provides a mock function with given fields: client, bountyId +func (_m *StakeManagerUtils) GetBountyLock(client *ethclient.Client, bountyId uint32) (types.BountyLock, error) { + ret := _m.Called(client, bountyId) + + var r0 types.BountyLock + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (types.BountyLock, error)); ok { + return rf(client, bountyId) + } + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) types.BountyLock); ok { + r0 = rf(client, bountyId) + } else { + r0 = ret.Get(0).(types.BountyLock) + } + + if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { + r1 = rf(client, bountyId) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetMaturity provides a mock function with given fields: client, age +func (_m *StakeManagerUtils) GetMaturity(client *ethclient.Client, age uint32) (uint16, error) { + ret := _m.Called(client, age) + + var r0 uint16 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (uint16, error)); ok { + return rf(client, age) + } + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) uint16); ok { + r0 = rf(client, age) + } else { + r0 = ret.Get(0).(uint16) + } + + if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { + r1 = rf(client, age) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // GetNumStakers provides a mock function with given fields: client func (_m *StakeManagerUtils) GetNumStakers(client *ethclient.Client) (uint32, error) { ret := _m.Called(client) var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint32, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) uint32); ok { r0 = rf(client) } else { r0 = ret.Get(0).(uint32) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -67,13 +121,16 @@ func (_m *StakeManagerUtils) GetStaker(client *ethclient.Client, stakerId uint32 ret := _m.Called(client, stakerId) var r0 bindings.StructsStaker + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (bindings.StructsStaker, error)); ok { + return rf(client, stakerId) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) bindings.StructsStaker); ok { r0 = rf(client, stakerId) } else { r0 = ret.Get(0).(bindings.StructsStaker) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { r1 = rf(client, stakerId) } else { @@ -88,13 +145,16 @@ func (_m *StakeManagerUtils) GetStakerId(client *ethclient.Client, address commo ret := _m.Called(client, address) var r0 uint32 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address) (uint32, error)); ok { + return rf(client, address) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address) uint32); ok { r0 = rf(client, address) } else { r0 = ret.Get(0).(uint32) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, common.Address) error); ok { r1 = rf(client, address) } else { @@ -109,13 +169,16 @@ func (_m *StakeManagerUtils) Locks(client *ethclient.Client, address common.Addr ret := _m.Called(client, address, address1, lockType) var r0 types.Locks + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address, common.Address, uint8) (types.Locks, error)); ok { + return rf(client, address, address1, lockType) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address, common.Address, uint8) types.Locks); ok { r0 = rf(client, address, address1, lockType) } else { r0 = ret.Get(0).(types.Locks) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, common.Address, common.Address, uint8) error); ok { r1 = rf(client, address, address1, lockType) } else { @@ -130,13 +193,16 @@ func (_m *StakeManagerUtils) MaxCommission(client *ethclient.Client) (uint8, err ret := _m.Called(client) var r0 uint8 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint8, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) uint8); ok { r0 = rf(client) } else { r0 = ret.Get(0).(uint8) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -151,6 +217,10 @@ func (_m *StakeManagerUtils) MinSafeRazor(client *ethclient.Client) (*big.Int, e ret := _m.Called(client) var r0 *big.Int + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (*big.Int, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) *big.Int); ok { r0 = rf(client) } else { @@ -159,7 +229,6 @@ func (_m *StakeManagerUtils) MinSafeRazor(client *ethclient.Client) (*big.Int, e } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -169,18 +238,45 @@ func (_m *StakeManagerUtils) MinSafeRazor(client *ethclient.Client) (*big.Int, e return r0, r1 } +// StakerInfo provides a mock function with given fields: client, stakerId +func (_m *StakeManagerUtils) StakerInfo(client *ethclient.Client, stakerId uint32) (types.Staker, error) { + ret := _m.Called(client, stakerId) + + var r0 types.Staker + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (types.Staker, error)); ok { + return rf(client, stakerId) + } + if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) types.Staker); ok { + r0 = rf(client, stakerId) + } else { + r0 = ret.Get(0).(types.Staker) + } + + if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { + r1 = rf(client, stakerId) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // WithdrawInitiationPeriod provides a mock function with given fields: client func (_m *StakeManagerUtils) WithdrawInitiationPeriod(client *ethclient.Client) (uint16, error) { ret := _m.Called(client) var r0 uint16 + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint16, error)); ok { + return rf(client) + } if rf, ok := ret.Get(0).(func(*ethclient.Client) uint16); ok { r0 = rf(client) } else { r0 = ret.Get(0).(uint16) } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { r1 = rf(client) } else { @@ -190,13 +286,12 @@ func (_m *StakeManagerUtils) WithdrawInitiationPeriod(client *ethclient.Client) return r0, r1 } -type mockConstructorTestingTNewStakeManagerUtils interface { +// NewStakeManagerUtils creates a new instance of StakeManagerUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStakeManagerUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewStakeManagerUtils creates a new instance of StakeManagerUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewStakeManagerUtils(t mockConstructorTestingTNewStakeManagerUtils) *StakeManagerUtils { +}) *StakeManagerUtils { mock := &StakeManagerUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/staked_token_utils.go b/utils/mocks/staked_token_utils.go index a502ee966..6acdb5a67 100644 --- a/utils/mocks/staked_token_utils.go +++ b/utils/mocks/staked_token_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -21,6 +21,10 @@ func (_m *StakedTokenUtils) BalanceOf(client *ethclient.Client, tokenAddress com ret := _m.Called(client, tokenAddress, address) var r0 *big.Int + var r1 error + if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address, common.Address) (*big.Int, error)); ok { + return rf(client, tokenAddress, address) + } if rf, ok := ret.Get(0).(func(*ethclient.Client, common.Address, common.Address) *big.Int); ok { r0 = rf(client, tokenAddress, address) } else { @@ -29,7 +33,6 @@ func (_m *StakedTokenUtils) BalanceOf(client *ethclient.Client, tokenAddress com } } - var r1 error if rf, ok := ret.Get(1).(func(*ethclient.Client, common.Address, common.Address) error); ok { r1 = rf(client, tokenAddress, address) } else { @@ -39,13 +42,12 @@ func (_m *StakedTokenUtils) BalanceOf(client *ethclient.Client, tokenAddress com return r0, r1 } -type mockConstructorTestingTNewStakedTokenUtils interface { +// NewStakedTokenUtils creates a new instance of StakedTokenUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStakedTokenUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewStakedTokenUtils creates a new instance of StakedTokenUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewStakedTokenUtils(t mockConstructorTestingTNewStakedTokenUtils) *StakedTokenUtils { +}) *StakedTokenUtils { mock := &StakedTokenUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/time_utils.go b/utils/mocks/time_utils.go index 118542bef..ef3af8cba 100644 --- a/utils/mocks/time_utils.go +++ b/utils/mocks/time_utils.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.14.0. DO NOT EDIT. +// Code generated by mockery v2.30.1. DO NOT EDIT. package mocks @@ -18,13 +18,12 @@ func (_m *TimeUtils) Sleep(duration time.Duration) { _m.Called(duration) } -type mockConstructorTestingTNewTimeUtils interface { +// NewTimeUtils creates a new instance of TimeUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTimeUtils(t interface { mock.TestingT Cleanup(func()) -} - -// NewTimeUtils creates a new instance of TimeUtils. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewTimeUtils(t mockConstructorTestingTNewTimeUtils) *TimeUtils { +}) *TimeUtils { mock := &TimeUtils{} mock.Mock.Test(t) diff --git a/utils/mocks/utils.go b/utils/mocks/utils.go index 869a2fbcb..15a866d69 100644 --- a/utils/mocks/utils.go +++ b/utils/mocks/utils.go @@ -20,6 +20,8 @@ import ( pflag "github.com/spf13/pflag" + rpc "razor/rpc" + types "razor/core/types" ) @@ -68,25 +70,51 @@ func (_m *Utils) AddJobToJSON(fileName string, job *types.StructsJob) error { return r0 } -// Aggregate provides a mock function with given fields: client, previousEpoch, collection, commitParams -func (_m *Utils) Aggregate(client *ethclient.Client, previousEpoch uint32, collection bindings.StructsCollection, commitParams *types.CommitParams) (*big.Int, error) { - ret := _m.Called(client, previousEpoch, collection, commitParams) +// Aggregate provides a mock function with given fields: rpcParameters, previousEpoch, collection, commitParams +func (_m *Utils) Aggregate(rpcParameters rpc.RPCParameters, previousEpoch uint32, collection bindings.StructsCollection, commitParams *types.CommitParams) (*big.Int, error) { + ret := _m.Called(rpcParameters, previousEpoch, collection, commitParams) + + var r0 *big.Int + var r1 error + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, bindings.StructsCollection, *types.CommitParams) (*big.Int, error)); ok { + return rf(rpcParameters, previousEpoch, collection, commitParams) + } + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, bindings.StructsCollection, *types.CommitParams) *big.Int); ok { + r0 = rf(rpcParameters, previousEpoch, collection, commitParams) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*big.Int) + } + } + + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32, bindings.StructsCollection, *types.CommitParams) error); ok { + r1 = rf(rpcParameters, previousEpoch, collection, commitParams) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Allowance provides a mock function with given fields: rpcParameters, owner, spender +func (_m *Utils) Allowance(rpcParameters rpc.RPCParameters, owner common.Address, spender common.Address) (*big.Int, error) { + ret := _m.Called(rpcParameters, owner, spender) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, bindings.StructsCollection, *types.CommitParams) (*big.Int, error)); ok { - return rf(client, previousEpoch, collection, commitParams) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, common.Address, common.Address) (*big.Int, error)); ok { + return rf(rpcParameters, owner, spender) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, bindings.StructsCollection, *types.CommitParams) *big.Int); ok { - r0 = rf(client, previousEpoch, collection, commitParams) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, common.Address, common.Address) *big.Int); ok { + r0 = rf(rpcParameters, owner, spender) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, bindings.StructsCollection, *types.CommitParams) error); ok { - r1 = rf(client, previousEpoch, collection, commitParams) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, common.Address, common.Address) error); ok { + r1 = rf(rpcParameters, owner, spender) } else { r1 = ret.Error(1) } @@ -108,23 +136,23 @@ func (_m *Utils) AssignPassword(flagSet *pflag.FlagSet) string { return r0 } -// AssignStakerId provides a mock function with given fields: flagSet, client, address -func (_m *Utils) AssignStakerId(flagSet *pflag.FlagSet, client *ethclient.Client, address string) (uint32, error) { - ret := _m.Called(flagSet, client, address) +// AssignStakerId provides a mock function with given fields: rpcParameters, flagSet, address +func (_m *Utils) AssignStakerId(rpcParameters rpc.RPCParameters, flagSet *pflag.FlagSet, address string) (uint32, error) { + ret := _m.Called(rpcParameters, flagSet, address) var r0 uint32 var r1 error - if rf, ok := ret.Get(0).(func(*pflag.FlagSet, *ethclient.Client, string) (uint32, error)); ok { - return rf(flagSet, client, address) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, *pflag.FlagSet, string) (uint32, error)); ok { + return rf(rpcParameters, flagSet, address) } - if rf, ok := ret.Get(0).(func(*pflag.FlagSet, *ethclient.Client, string) uint32); ok { - r0 = rf(flagSet, client, address) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, *pflag.FlagSet, string) uint32); ok { + r0 = rf(rpcParameters, flagSet, address) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*pflag.FlagSet, *ethclient.Client, string) error); ok { - r1 = rf(flagSet, client, address) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, *pflag.FlagSet, string) error); ok { + r1 = rf(rpcParameters, flagSet, address) } else { r1 = ret.Error(1) } @@ -132,13 +160,13 @@ func (_m *Utils) AssignStakerId(flagSet *pflag.FlagSet, client *ethclient.Client return r0, r1 } -// CalculateBlockTime provides a mock function with given fields: client -func (_m *Utils) CalculateBlockTime(client *ethclient.Client) int64 { - ret := _m.Called(client) +// CalculateBlockTime provides a mock function with given fields: rpcParameters +func (_m *Utils) CalculateBlockTime(rpcParameters rpc.RPCParameters) int64 { + ret := _m.Called(rpcParameters) var r0 int64 - if rf, ok := ret.Get(0).(func(*ethclient.Client) int64); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) int64); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(int64) } @@ -178,9 +206,9 @@ func (_m *Utils) CheckAmountAndBalance(amountInWei *big.Int, balance *big.Int) * return r0 } -// CheckEthBalanceIsZero provides a mock function with given fields: client, address -func (_m *Utils) CheckEthBalanceIsZero(client *ethclient.Client, address string) { - _m.Called(client, address) +// CheckEthBalanceIsZero provides a mock function with given fields: rpcParameters, address +func (_m *Utils) CheckEthBalanceIsZero(rpcParameters rpc.RPCParameters, address string) { + _m.Called(rpcParameters, address) } // CheckPassword provides a mock function with given fields: account @@ -197,13 +225,13 @@ func (_m *Utils) CheckPassword(account types.Account) error { return r0 } -// CheckTransactionReceipt provides a mock function with given fields: client, _txHash -func (_m *Utils) CheckTransactionReceipt(client *ethclient.Client, _txHash string) int { - ret := _m.Called(client, _txHash) +// CheckTransactionReceipt provides a mock function with given fields: rpcManager, _txHash +func (_m *Utils) CheckTransactionReceipt(rpcManager rpc.RPCParameters, _txHash string) int { + ret := _m.Called(rpcManager, _txHash) var r0 int - if rf, ok := ret.Get(0).(func(*ethclient.Client, string) int); ok { - r0 = rf(client, _txHash) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, string) int); ok { + r0 = rf(rpcManager, _txHash) } else { r0 = ret.Get(0).(int) } @@ -241,25 +269,49 @@ func (_m *Utils) DeleteJobFromJSON(fileName string, jobId string) error { return r0 } -// EstimateBlockNumberAtEpochBeginning provides a mock function with given fields: client, currentBlockNumber -func (_m *Utils) EstimateBlockNumberAtEpochBeginning(client *ethclient.Client, currentBlockNumber *big.Int) (*big.Int, error) { - ret := _m.Called(client, currentBlockNumber) +// Disputes provides a mock function with given fields: rpcParameters, epoch, address +func (_m *Utils) Disputes(rpcParameters rpc.RPCParameters, epoch uint32, address common.Address) (types.DisputesStruct, error) { + ret := _m.Called(rpcParameters, epoch, address) + + var r0 types.DisputesStruct + var r1 error + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, common.Address) (types.DisputesStruct, error)); ok { + return rf(rpcParameters, epoch, address) + } + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, common.Address) types.DisputesStruct); ok { + r0 = rf(rpcParameters, epoch, address) + } else { + r0 = ret.Get(0).(types.DisputesStruct) + } + + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32, common.Address) error); ok { + r1 = rf(rpcParameters, epoch, address) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EstimateBlockNumberAtEpochBeginning provides a mock function with given fields: rpcParameters, currentBlockNumber +func (_m *Utils) EstimateBlockNumberAtEpochBeginning(rpcParameters rpc.RPCParameters, currentBlockNumber *big.Int) (*big.Int, error) { + ret := _m.Called(rpcParameters, currentBlockNumber) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, *big.Int) (*big.Int, error)); ok { - return rf(client, currentBlockNumber) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, *big.Int) (*big.Int, error)); ok { + return rf(rpcParameters, currentBlockNumber) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, *big.Int) *big.Int); ok { - r0 = rf(client, currentBlockNumber) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, *big.Int) *big.Int); ok { + r0 = rf(rpcParameters, currentBlockNumber) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, *big.Int) error); ok { - r1 = rf(client, currentBlockNumber) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, *big.Int) error); ok { + r1 = rf(rpcParameters, currentBlockNumber) } else { r1 = ret.Error(1) } @@ -267,25 +319,25 @@ func (_m *Utils) EstimateBlockNumberAtEpochBeginning(client *ethclient.Client, c return r0, r1 } -// FetchBalance provides a mock function with given fields: client, accountAddress -func (_m *Utils) FetchBalance(client *ethclient.Client, accountAddress string) (*big.Int, error) { - ret := _m.Called(client, accountAddress) +// FetchBalance provides a mock function with given fields: rpcParameters, accountAddress +func (_m *Utils) FetchBalance(rpcParameters rpc.RPCParameters, accountAddress string) (*big.Int, error) { + ret := _m.Called(rpcParameters, accountAddress) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, string) (*big.Int, error)); ok { - return rf(client, accountAddress) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, string) (*big.Int, error)); ok { + return rf(rpcParameters, accountAddress) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, string) *big.Int); ok { - r0 = rf(client, accountAddress) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, string) *big.Int); ok { + r0 = rf(rpcParameters, accountAddress) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, string) error); ok { - r1 = rf(client, accountAddress) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, string) error); ok { + r1 = rf(rpcParameters, accountAddress) } else { r1 = ret.Error(1) } @@ -293,25 +345,25 @@ func (_m *Utils) FetchBalance(client *ethclient.Client, accountAddress string) ( return r0, r1 } -// FetchPreviousValue provides a mock function with given fields: client, epoch, assetId -func (_m *Utils) FetchPreviousValue(client *ethclient.Client, epoch uint32, assetId uint16) (*big.Int, error) { - ret := _m.Called(client, epoch, assetId) +// FetchPreviousValue provides a mock function with given fields: rpcParameters, epoch, assetId +func (_m *Utils) FetchPreviousValue(rpcParameters rpc.RPCParameters, epoch uint32, assetId uint16) (*big.Int, error) { + ret := _m.Called(rpcParameters, epoch, assetId) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint16) (*big.Int, error)); ok { - return rf(client, epoch, assetId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint16) (*big.Int, error)); ok { + return rf(rpcParameters, epoch, assetId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint16) *big.Int); ok { - r0 = rf(client, epoch, assetId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint16) *big.Int); ok { + r0 = rf(rpcParameters, epoch, assetId) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, uint16) error); ok { - r1 = rf(client, epoch, assetId) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32, uint16) error); ok { + r1 = rf(rpcParameters, epoch, assetId) } else { r1 = ret.Error(1) } @@ -343,25 +395,25 @@ func (_m *Utils) GetActiveCollection(collectionsCache *cache.CollectionsCache, c return r0, r1 } -// GetActiveCollectionIds provides a mock function with given fields: client -func (_m *Utils) GetActiveCollectionIds(client *ethclient.Client) ([]uint16, error) { - ret := _m.Called(client) +// GetActiveCollectionIds provides a mock function with given fields: rpcParameters +func (_m *Utils) GetActiveCollectionIds(rpcParameters rpc.RPCParameters) ([]uint16, error) { + ret := _m.Called(rpcParameters) var r0 []uint16 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) ([]uint16, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) ([]uint16, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) []uint16); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) []uint16); ok { + r0 = rf(rpcParameters) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]uint16) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -369,23 +421,47 @@ func (_m *Utils) GetActiveCollectionIds(client *ethclient.Client) ([]uint16, err return r0, r1 } -// GetActiveJob provides a mock function with given fields: client, jobId -func (_m *Utils) GetActiveJob(client *ethclient.Client, jobId uint16) (bindings.StructsJob, error) { - ret := _m.Called(client, jobId) +// GetActiveJob provides a mock function with given fields: rpcParameters, jobId +func (_m *Utils) GetActiveJob(rpcParameters rpc.RPCParameters, jobId uint16) (bindings.StructsJob, error) { + ret := _m.Called(rpcParameters, jobId) var r0 bindings.StructsJob var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (bindings.StructsJob, error)); ok { - return rf(client, jobId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) (bindings.StructsJob, error)); ok { + return rf(rpcParameters, jobId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) bindings.StructsJob); ok { - r0 = rf(client, jobId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) bindings.StructsJob); ok { + r0 = rf(rpcParameters, jobId) } else { r0 = ret.Get(0).(bindings.StructsJob) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { - r1 = rf(client, jobId) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint16) error); ok { + r1 = rf(rpcParameters, jobId) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetActiveStatus provides a mock function with given fields: rpcParameters, id +func (_m *Utils) GetActiveStatus(rpcParameters rpc.RPCParameters, id uint16) (bool, error) { + ret := _m.Called(rpcParameters, id) + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) (bool, error)); ok { + return rf(rpcParameters, id) + } + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) bool); ok { + r0 = rf(rpcParameters, id) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint16) error); ok { + r1 = rf(rpcParameters, id) } else { r1 = ret.Error(1) } @@ -393,25 +469,25 @@ func (_m *Utils) GetActiveJob(client *ethclient.Client, jobId uint16) (bindings. return r0, r1 } -// GetAggregatedDataOfCollection provides a mock function with given fields: client, collectionId, epoch, commitParams -func (_m *Utils) GetAggregatedDataOfCollection(client *ethclient.Client, collectionId uint16, epoch uint32, commitParams *types.CommitParams) (*big.Int, error) { - ret := _m.Called(client, collectionId, epoch, commitParams) +// GetAggregatedDataOfCollection provides a mock function with given fields: rpcParameters, collectionId, epoch, commitParams +func (_m *Utils) GetAggregatedDataOfCollection(rpcParameters rpc.RPCParameters, collectionId uint16, epoch uint32, commitParams *types.CommitParams) (*big.Int, error) { + ret := _m.Called(rpcParameters, collectionId, epoch, commitParams) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16, uint32, *types.CommitParams) (*big.Int, error)); ok { - return rf(client, collectionId, epoch, commitParams) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16, uint32, *types.CommitParams) (*big.Int, error)); ok { + return rf(rpcParameters, collectionId, epoch, commitParams) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16, uint32, *types.CommitParams) *big.Int); ok { - r0 = rf(client, collectionId, epoch, commitParams) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16, uint32, *types.CommitParams) *big.Int); ok { + r0 = rf(rpcParameters, collectionId, epoch, commitParams) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16, uint32, *types.CommitParams) error); ok { - r1 = rf(client, collectionId, epoch, commitParams) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint16, uint32, *types.CommitParams) error); ok { + r1 = rf(rpcParameters, collectionId, epoch, commitParams) } else { r1 = ret.Error(1) } @@ -419,25 +495,25 @@ func (_m *Utils) GetAggregatedDataOfCollection(client *ethclient.Client, collect return r0, r1 } -// GetAllCollections provides a mock function with given fields: client -func (_m *Utils) GetAllCollections(client *ethclient.Client) ([]bindings.StructsCollection, error) { - ret := _m.Called(client) +// GetAllCollections provides a mock function with given fields: rpcParameters +func (_m *Utils) GetAllCollections(rpcParameters rpc.RPCParameters) ([]bindings.StructsCollection, error) { + ret := _m.Called(rpcParameters) var r0 []bindings.StructsCollection var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) ([]bindings.StructsCollection, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) ([]bindings.StructsCollection, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) []bindings.StructsCollection); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) []bindings.StructsCollection); ok { + r0 = rf(rpcParameters) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]bindings.StructsCollection) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -445,34 +521,34 @@ func (_m *Utils) GetAllCollections(client *ethclient.Client) ([]bindings.Structs return r0, r1 } -// GetAssignedCollections provides a mock function with given fields: client, numActiveCollections, seed -func (_m *Utils) GetAssignedCollections(client *ethclient.Client, numActiveCollections uint16, seed []byte) (map[int]bool, []*big.Int, error) { - ret := _m.Called(client, numActiveCollections, seed) +// GetAssignedCollections provides a mock function with given fields: rpcParameters, numActiveCollections, seed +func (_m *Utils) GetAssignedCollections(rpcParameters rpc.RPCParameters, numActiveCollections uint16, seed []byte) (map[int]bool, []*big.Int, error) { + ret := _m.Called(rpcParameters, numActiveCollections, seed) var r0 map[int]bool var r1 []*big.Int var r2 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16, []byte) (map[int]bool, []*big.Int, error)); ok { - return rf(client, numActiveCollections, seed) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16, []byte) (map[int]bool, []*big.Int, error)); ok { + return rf(rpcParameters, numActiveCollections, seed) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16, []byte) map[int]bool); ok { - r0 = rf(client, numActiveCollections, seed) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16, []byte) map[int]bool); ok { + r0 = rf(rpcParameters, numActiveCollections, seed) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(map[int]bool) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16, []byte) []*big.Int); ok { - r1 = rf(client, numActiveCollections, seed) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint16, []byte) []*big.Int); ok { + r1 = rf(rpcParameters, numActiveCollections, seed) } else { if ret.Get(1) != nil { r1 = ret.Get(1).([]*big.Int) } } - if rf, ok := ret.Get(2).(func(*ethclient.Client, uint16, []byte) error); ok { - r2 = rf(client, numActiveCollections, seed) + if rf, ok := ret.Get(2).(func(rpc.RPCParameters, uint16, []byte) error); ok { + r2 = rf(rpcParameters, numActiveCollections, seed) } else { r2 = ret.Error(2) } @@ -480,23 +556,23 @@ func (_m *Utils) GetAssignedCollections(client *ethclient.Client, numActiveColle return r0, r1, r2 } -// GetBlock provides a mock function with given fields: client, epoch -func (_m *Utils) GetBlock(client *ethclient.Client, epoch uint32) (bindings.StructsBlock, error) { - ret := _m.Called(client, epoch) +// GetBlock provides a mock function with given fields: rpcParameters, epoch +func (_m *Utils) GetBlock(rpcParameters rpc.RPCParameters, epoch uint32) (bindings.StructsBlock, error) { + ret := _m.Called(rpcParameters, epoch) var r0 bindings.StructsBlock var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (bindings.StructsBlock, error)); ok { - return rf(client, epoch) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) (bindings.StructsBlock, error)); ok { + return rf(rpcParameters, epoch) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) bindings.StructsBlock); ok { - r0 = rf(client, epoch) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) bindings.StructsBlock); ok { + r0 = rf(rpcParameters, epoch) } else { r0 = ret.Get(0).(bindings.StructsBlock) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { - r1 = rf(client, epoch) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, epoch) } else { r1 = ret.Error(1) } @@ -504,23 +580,23 @@ func (_m *Utils) GetBlock(client *ethclient.Client, epoch uint32) (bindings.Stru return r0, r1 } -// GetBlockIndexToBeConfirmed provides a mock function with given fields: client -func (_m *Utils) GetBlockIndexToBeConfirmed(client *ethclient.Client) (int8, error) { - ret := _m.Called(client) +// GetBlockIndexToBeConfirmed provides a mock function with given fields: rpcParameters +func (_m *Utils) GetBlockIndexToBeConfirmed(rpcParameters rpc.RPCParameters) (int8, error) { + ret := _m.Called(rpcParameters) var r0 int8 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (int8, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (int8, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) int8); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) int8); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(int8) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -570,23 +646,47 @@ func (_m *Utils) GetBlockManagerWithOpts(client *ethclient.Client) (*bindings.Bl return r0, r1 } -// GetBufferedState provides a mock function with given fields: client, header, buffer -func (_m *Utils) GetBufferedState(client *ethclient.Client, header *coretypes.Header, buffer int32) (int64, error) { - ret := _m.Called(client, header, buffer) +// GetBountyLock provides a mock function with given fields: rpcParameters, bountyId +func (_m *Utils) GetBountyLock(rpcParameters rpc.RPCParameters, bountyId uint32) (types.BountyLock, error) { + ret := _m.Called(rpcParameters, bountyId) + + var r0 types.BountyLock + var r1 error + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) (types.BountyLock, error)); ok { + return rf(rpcParameters, bountyId) + } + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) types.BountyLock); ok { + r0 = rf(rpcParameters, bountyId) + } else { + r0 = ret.Get(0).(types.BountyLock) + } + + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, bountyId) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetBufferedState provides a mock function with given fields: header, stateBuffer, buffer +func (_m *Utils) GetBufferedState(header *coretypes.Header, stateBuffer uint64, buffer int32) (int64, error) { + ret := _m.Called(header, stateBuffer, buffer) var r0 int64 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, *coretypes.Header, int32) (int64, error)); ok { - return rf(client, header, buffer) + if rf, ok := ret.Get(0).(func(*coretypes.Header, uint64, int32) (int64, error)); ok { + return rf(header, stateBuffer, buffer) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, *coretypes.Header, int32) int64); ok { - r0 = rf(client, header, buffer) + if rf, ok := ret.Get(0).(func(*coretypes.Header, uint64, int32) int64); ok { + r0 = rf(header, stateBuffer, buffer) } else { r0 = ret.Get(0).(int64) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, *coretypes.Header, int32) error); ok { - r1 = rf(client, header, buffer) + if rf, ok := ret.Get(1).(func(*coretypes.Header, uint64, int32) error); ok { + r1 = rf(header, stateBuffer, buffer) } else { r1 = ret.Error(1) } @@ -594,23 +694,23 @@ func (_m *Utils) GetBufferedState(client *ethclient.Client, header *coretypes.He return r0, r1 } -// GetCollection provides a mock function with given fields: client, collectionId -func (_m *Utils) GetCollection(client *ethclient.Client, collectionId uint16) (bindings.StructsCollection, error) { - ret := _m.Called(client, collectionId) +// GetCollection provides a mock function with given fields: rpcParameters, collectionId +func (_m *Utils) GetCollection(rpcParameters rpc.RPCParameters, collectionId uint16) (bindings.StructsCollection, error) { + ret := _m.Called(rpcParameters, collectionId) var r0 bindings.StructsCollection var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (bindings.StructsCollection, error)); ok { - return rf(client, collectionId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) (bindings.StructsCollection, error)); ok { + return rf(rpcParameters, collectionId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) bindings.StructsCollection); ok { - r0 = rf(client, collectionId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) bindings.StructsCollection); ok { + r0 = rf(rpcParameters, collectionId) } else { r0 = ret.Get(0).(bindings.StructsCollection) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { - r1 = rf(client, collectionId) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint16) error); ok { + r1 = rf(rpcParameters, collectionId) } else { r1 = ret.Error(1) } @@ -618,23 +718,23 @@ func (_m *Utils) GetCollection(client *ethclient.Client, collectionId uint16) (b return r0, r1 } -// GetCollectionIdFromIndex provides a mock function with given fields: client, medianIndex -func (_m *Utils) GetCollectionIdFromIndex(client *ethclient.Client, medianIndex uint16) (uint16, error) { - ret := _m.Called(client, medianIndex) +// GetCollectionIdFromIndex provides a mock function with given fields: rpcParameters, medianIndex +func (_m *Utils) GetCollectionIdFromIndex(rpcParameters rpc.RPCParameters, medianIndex uint16) (uint16, error) { + ret := _m.Called(rpcParameters, medianIndex) var r0 uint16 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (uint16, error)); ok { - return rf(client, medianIndex) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) (uint16, error)); ok { + return rf(rpcParameters, medianIndex) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) uint16); ok { - r0 = rf(client, medianIndex) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) uint16); ok { + r0 = rf(rpcParameters, medianIndex) } else { r0 = ret.Get(0).(uint16) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { - r1 = rf(client, medianIndex) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint16) error); ok { + r1 = rf(rpcParameters, medianIndex) } else { r1 = ret.Error(1) } @@ -642,23 +742,23 @@ func (_m *Utils) GetCollectionIdFromIndex(client *ethclient.Client, medianIndex return r0, r1 } -// GetCollectionIdFromLeafId provides a mock function with given fields: client, leafId -func (_m *Utils) GetCollectionIdFromLeafId(client *ethclient.Client, leafId uint16) (uint16, error) { - ret := _m.Called(client, leafId) +// GetCollectionIdFromLeafId provides a mock function with given fields: rpcParameters, leafId +func (_m *Utils) GetCollectionIdFromLeafId(rpcParameters rpc.RPCParameters, leafId uint16) (uint16, error) { + ret := _m.Called(rpcParameters, leafId) var r0 uint16 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (uint16, error)); ok { - return rf(client, leafId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) (uint16, error)); ok { + return rf(rpcParameters, leafId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) uint16); ok { - r0 = rf(client, leafId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) uint16); ok { + r0 = rf(rpcParameters, leafId) } else { r0 = ret.Get(0).(uint16) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { - r1 = rf(client, leafId) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint16) error); ok { + r1 = rf(rpcParameters, leafId) } else { r1 = ret.Error(1) } @@ -708,23 +808,47 @@ func (_m *Utils) GetCollectionManagerWithOpts(client *ethclient.Client) (*bindin return r0, r1 } -// GetCommitment provides a mock function with given fields: client, address -func (_m *Utils) GetCommitment(client *ethclient.Client, address string) (types.Commitment, error) { - ret := _m.Called(client, address) +// GetCommitment provides a mock function with given fields: rpcParameters, address +func (_m *Utils) GetCommitment(rpcParameters rpc.RPCParameters, address string) (types.Commitment, error) { + ret := _m.Called(rpcParameters, address) var r0 types.Commitment var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, string) (types.Commitment, error)); ok { - return rf(client, address) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, string) (types.Commitment, error)); ok { + return rf(rpcParameters, address) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, string) types.Commitment); ok { - r0 = rf(client, address) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, string) types.Commitment); ok { + r0 = rf(rpcParameters, address) } else { r0 = ret.Get(0).(types.Commitment) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, string) error); ok { - r1 = rf(client, address) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, string) error); ok { + r1 = rf(rpcParameters, address) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetConfirmedBlocks provides a mock function with given fields: rpcParameters, epoch +func (_m *Utils) GetConfirmedBlocks(rpcParameters rpc.RPCParameters, epoch uint32) (types.ConfirmedBlock, error) { + ret := _m.Called(rpcParameters, epoch) + + var r0 types.ConfirmedBlock + var r1 error + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) (types.ConfirmedBlock, error)); ok { + return rf(rpcParameters, epoch) + } + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) types.ConfirmedBlock); ok { + r0 = rf(rpcParameters, epoch) + } else { + r0 = ret.Get(0).(types.ConfirmedBlock) + } + + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, epoch) } else { r1 = ret.Error(1) } @@ -786,23 +910,23 @@ func (_m *Utils) GetDataToCommitFromJobs(jobs []bindings.StructsJob, commitParam return r0, r1 } -// GetEpoch provides a mock function with given fields: client -func (_m *Utils) GetEpoch(client *ethclient.Client) (uint32, error) { - ret := _m.Called(client) +// GetEpoch provides a mock function with given fields: rpcParameters +func (_m *Utils) GetEpoch(rpcParameters rpc.RPCParameters) (uint32, error) { + ret := _m.Called(rpcParameters) var r0 uint32 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint32, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (uint32, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) uint32); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) uint32); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -810,23 +934,23 @@ func (_m *Utils) GetEpoch(client *ethclient.Client) (uint32, error) { return r0, r1 } -// GetEpochLastCommitted provides a mock function with given fields: client, stakerId -func (_m *Utils) GetEpochLastCommitted(client *ethclient.Client, stakerId uint32) (uint32, error) { - ret := _m.Called(client, stakerId) +// GetEpochLastCommitted provides a mock function with given fields: rpcParameters, stakerId +func (_m *Utils) GetEpochLastCommitted(rpcParameters rpc.RPCParameters, stakerId uint32) (uint32, error) { + ret := _m.Called(rpcParameters, stakerId) var r0 uint32 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (uint32, error)); ok { - return rf(client, stakerId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) (uint32, error)); ok { + return rf(rpcParameters, stakerId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) uint32); ok { - r0 = rf(client, stakerId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) uint32); ok { + r0 = rf(rpcParameters, stakerId) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { - r1 = rf(client, stakerId) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, stakerId) } else { r1 = ret.Error(1) } @@ -834,23 +958,23 @@ func (_m *Utils) GetEpochLastCommitted(client *ethclient.Client, stakerId uint32 return r0, r1 } -// GetEpochLastProposed provides a mock function with given fields: client, stakerId -func (_m *Utils) GetEpochLastProposed(client *ethclient.Client, stakerId uint32) (uint32, error) { - ret := _m.Called(client, stakerId) +// GetEpochLastProposed provides a mock function with given fields: rpcParameters, stakerId +func (_m *Utils) GetEpochLastProposed(rpcParameters rpc.RPCParameters, stakerId uint32) (uint32, error) { + ret := _m.Called(rpcParameters, stakerId) var r0 uint32 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (uint32, error)); ok { - return rf(client, stakerId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) (uint32, error)); ok { + return rf(rpcParameters, stakerId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) uint32); ok { - r0 = rf(client, stakerId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) uint32); ok { + r0 = rf(rpcParameters, stakerId) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { - r1 = rf(client, stakerId) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, stakerId) } else { r1 = ret.Error(1) } @@ -858,23 +982,23 @@ func (_m *Utils) GetEpochLastProposed(client *ethclient.Client, stakerId uint32) return r0, r1 } -// GetEpochLastRevealed provides a mock function with given fields: client, stakerId -func (_m *Utils) GetEpochLastRevealed(client *ethclient.Client, stakerId uint32) (uint32, error) { - ret := _m.Called(client, stakerId) +// GetEpochLastRevealed provides a mock function with given fields: rpcParameters, stakerId +func (_m *Utils) GetEpochLastRevealed(rpcParameters rpc.RPCParameters, stakerId uint32) (uint32, error) { + ret := _m.Called(rpcParameters, stakerId) var r0 uint32 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (uint32, error)); ok { - return rf(client, stakerId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) (uint32, error)); ok { + return rf(rpcParameters, stakerId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) uint32); ok { - r0 = rf(client, stakerId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) uint32); ok { + r0 = rf(rpcParameters, stakerId) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { - r1 = rf(client, stakerId) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, stakerId) } else { r1 = ret.Error(1) } @@ -882,23 +1006,23 @@ func (_m *Utils) GetEpochLastRevealed(client *ethclient.Client, stakerId uint32) return r0, r1 } -// GetEpochLimitForUpdateCommission provides a mock function with given fields: client -func (_m *Utils) GetEpochLimitForUpdateCommission(client *ethclient.Client) (uint16, error) { - ret := _m.Called(client) +// GetEpochLimitForUpdateCommission provides a mock function with given fields: rpcParameters +func (_m *Utils) GetEpochLimitForUpdateCommission(rpcParameters rpc.RPCParameters) (uint16, error) { + ret := _m.Called(rpcParameters) var r0 uint16 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint16, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (uint16, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) uint16); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) uint16); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(uint16) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -906,25 +1030,25 @@ func (_m *Utils) GetEpochLimitForUpdateCommission(client *ethclient.Client) (uin return r0, r1 } -// GetInfluenceSnapshot provides a mock function with given fields: client, stakerId, epoch -func (_m *Utils) GetInfluenceSnapshot(client *ethclient.Client, stakerId uint32, epoch uint32) (*big.Int, error) { - ret := _m.Called(client, stakerId, epoch) +// GetInfluenceSnapshot provides a mock function with given fields: rpcParameters, stakerId, epoch +func (_m *Utils) GetInfluenceSnapshot(rpcParameters rpc.RPCParameters, stakerId uint32, epoch uint32) (*big.Int, error) { + ret := _m.Called(rpcParameters, stakerId, epoch) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32) (*big.Int, error)); ok { - return rf(client, stakerId, epoch) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint32) (*big.Int, error)); ok { + return rf(rpcParameters, stakerId, epoch) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32) *big.Int); ok { - r0 = rf(client, stakerId, epoch) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint32) *big.Int); ok { + r0 = rf(rpcParameters, stakerId, epoch) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, uint32) error); ok { - r1 = rf(client, stakerId, epoch) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32, uint32) error); ok { + r1 = rf(rpcParameters, stakerId, epoch) } else { r1 = ret.Error(1) } @@ -932,25 +1056,25 @@ func (_m *Utils) GetInfluenceSnapshot(client *ethclient.Client, stakerId uint32, return r0, r1 } -// GetJobs provides a mock function with given fields: client -func (_m *Utils) GetJobs(client *ethclient.Client) ([]bindings.StructsJob, error) { - ret := _m.Called(client) +// GetJobs provides a mock function with given fields: rpcParameters +func (_m *Utils) GetJobs(rpcParameters rpc.RPCParameters) ([]bindings.StructsJob, error) { + ret := _m.Called(rpcParameters) var r0 []bindings.StructsJob var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) ([]bindings.StructsJob, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) ([]bindings.StructsJob, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) []bindings.StructsJob); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) []bindings.StructsJob); ok { + r0 = rf(rpcParameters) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]bindings.StructsJob) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -958,23 +1082,23 @@ func (_m *Utils) GetJobs(client *ethclient.Client) ([]bindings.StructsJob, error return r0, r1 } -// GetLeafIdOfACollection provides a mock function with given fields: client, collectionId -func (_m *Utils) GetLeafIdOfACollection(client *ethclient.Client, collectionId uint16) (uint16, error) { - ret := _m.Called(client, collectionId) +// GetLeafIdOfACollection provides a mock function with given fields: rpcParameters, collectionId +func (_m *Utils) GetLeafIdOfACollection(rpcParameters rpc.RPCParameters, collectionId uint16) (uint16, error) { + ret := _m.Called(rpcParameters, collectionId) var r0 uint16 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) (uint16, error)); ok { - return rf(client, collectionId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) (uint16, error)); ok { + return rf(rpcParameters, collectionId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint16) uint16); ok { - r0 = rf(client, collectionId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint16) uint16); ok { + r0 = rf(rpcParameters, collectionId) } else { r0 = ret.Get(0).(uint16) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint16) error); ok { - r1 = rf(client, collectionId) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint16) error); ok { + r1 = rf(rpcParameters, collectionId) } else { r1 = ret.Error(1) } @@ -982,23 +1106,23 @@ func (_m *Utils) GetLeafIdOfACollection(client *ethclient.Client, collectionId u return r0, r1 } -// GetLock provides a mock function with given fields: client, address, stakerId, lockType -func (_m *Utils) GetLock(client *ethclient.Client, address string, stakerId uint32, lockType uint8) (types.Locks, error) { - ret := _m.Called(client, address, stakerId, lockType) +// GetLock provides a mock function with given fields: rpcParameters, address, stakerId, lockType +func (_m *Utils) GetLock(rpcParameters rpc.RPCParameters, address string, stakerId uint32, lockType uint8) (types.Locks, error) { + ret := _m.Called(rpcParameters, address, stakerId, lockType) var r0 types.Locks var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, string, uint32, uint8) (types.Locks, error)); ok { - return rf(client, address, stakerId, lockType) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, string, uint32, uint8) (types.Locks, error)); ok { + return rf(rpcParameters, address, stakerId, lockType) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, string, uint32, uint8) types.Locks); ok { - r0 = rf(client, address, stakerId, lockType) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, string, uint32, uint8) types.Locks); ok { + r0 = rf(rpcParameters, address, stakerId, lockType) } else { r0 = ret.Get(0).(types.Locks) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, string, uint32, uint8) error); ok { - r1 = rf(client, address, stakerId, lockType) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, string, uint32, uint8) error); ok { + r1 = rf(rpcParameters, address, stakerId, lockType) } else { r1 = ret.Error(1) } @@ -1006,23 +1130,47 @@ func (_m *Utils) GetLock(client *ethclient.Client, address string, stakerId uint return r0, r1 } -// GetMaxAltBlocks provides a mock function with given fields: client -func (_m *Utils) GetMaxAltBlocks(client *ethclient.Client) (uint8, error) { - ret := _m.Called(client) +// GetMaturity provides a mock function with given fields: rpcParameters, age +func (_m *Utils) GetMaturity(rpcParameters rpc.RPCParameters, age uint32) (uint16, error) { + ret := _m.Called(rpcParameters, age) + + var r0 uint16 + var r1 error + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) (uint16, error)); ok { + return rf(rpcParameters, age) + } + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) uint16); ok { + r0 = rf(rpcParameters, age) + } else { + r0 = ret.Get(0).(uint16) + } + + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, age) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetMaxAltBlocks provides a mock function with given fields: rpcParameters +func (_m *Utils) GetMaxAltBlocks(rpcParameters rpc.RPCParameters) (uint8, error) { + ret := _m.Called(rpcParameters) var r0 uint8 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint8, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (uint8, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) uint8); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) uint8); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(uint8) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -1030,23 +1178,23 @@ func (_m *Utils) GetMaxAltBlocks(client *ethclient.Client) (uint8, error) { return r0, r1 } -// GetMaxCommission provides a mock function with given fields: client -func (_m *Utils) GetMaxCommission(client *ethclient.Client) (uint8, error) { - ret := _m.Called(client) +// GetMaxCommission provides a mock function with given fields: rpcParameters +func (_m *Utils) GetMaxCommission(rpcParameters rpc.RPCParameters) (uint8, error) { + ret := _m.Called(rpcParameters) var r0 uint8 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint8, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (uint8, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) uint8); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) uint8); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(uint8) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -1054,25 +1202,25 @@ func (_m *Utils) GetMaxCommission(client *ethclient.Client) (uint8, error) { return r0, r1 } -// GetMinSafeRazor provides a mock function with given fields: client -func (_m *Utils) GetMinSafeRazor(client *ethclient.Client) (*big.Int, error) { - ret := _m.Called(client) +// GetMinSafeRazor provides a mock function with given fields: rpcParameters +func (_m *Utils) GetMinSafeRazor(rpcParameters rpc.RPCParameters) (*big.Int, error) { + ret := _m.Called(rpcParameters) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (*big.Int, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (*big.Int, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) *big.Int); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) *big.Int); ok { + r0 = rf(rpcParameters) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -1080,25 +1228,25 @@ func (_m *Utils) GetMinSafeRazor(client *ethclient.Client) (*big.Int, error) { return r0, r1 } -// GetMinStakeAmount provides a mock function with given fields: client -func (_m *Utils) GetMinStakeAmount(client *ethclient.Client) (*big.Int, error) { - ret := _m.Called(client) +// GetMinStakeAmount provides a mock function with given fields: rpcParameters +func (_m *Utils) GetMinStakeAmount(rpcParameters rpc.RPCParameters) (*big.Int, error) { + ret := _m.Called(rpcParameters) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (*big.Int, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (*big.Int, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) *big.Int); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) *big.Int); ok { + r0 = rf(rpcParameters) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -1106,23 +1254,23 @@ func (_m *Utils) GetMinStakeAmount(client *ethclient.Client) (*big.Int, error) { return r0, r1 } -// GetNumActiveCollections provides a mock function with given fields: client -func (_m *Utils) GetNumActiveCollections(client *ethclient.Client) (uint16, error) { - ret := _m.Called(client) +// GetNumActiveCollections provides a mock function with given fields: rpcParameters +func (_m *Utils) GetNumActiveCollections(rpcParameters rpc.RPCParameters) (uint16, error) { + ret := _m.Called(rpcParameters) var r0 uint16 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint16, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (uint16, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) uint16); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) uint16); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(uint16) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -1130,23 +1278,47 @@ func (_m *Utils) GetNumActiveCollections(client *ethclient.Client) (uint16, erro return r0, r1 } -// GetNumCollections provides a mock function with given fields: client -func (_m *Utils) GetNumCollections(client *ethclient.Client) (uint16, error) { - ret := _m.Called(client) +// GetNumCollections provides a mock function with given fields: rpcParameters +func (_m *Utils) GetNumCollections(rpcParameters rpc.RPCParameters) (uint16, error) { + ret := _m.Called(rpcParameters) var r0 uint16 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint16, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (uint16, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) uint16); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) uint16); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(uint16) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetNumJobs provides a mock function with given fields: rpcParameters +func (_m *Utils) GetNumJobs(rpcParameters rpc.RPCParameters) (uint16, error) { + ret := _m.Called(rpcParameters) + + var r0 uint16 + var r1 error + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (uint16, error)); ok { + return rf(rpcParameters) + } + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) uint16); ok { + r0 = rf(rpcParameters) + } else { + r0 = ret.Get(0).(uint16) + } + + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -1154,23 +1326,23 @@ func (_m *Utils) GetNumCollections(client *ethclient.Client) (uint16, error) { return r0, r1 } -// GetNumberOfProposedBlocks provides a mock function with given fields: client, epoch -func (_m *Utils) GetNumberOfProposedBlocks(client *ethclient.Client, epoch uint32) (uint8, error) { - ret := _m.Called(client, epoch) +// GetNumberOfProposedBlocks provides a mock function with given fields: rpcParameters, epoch +func (_m *Utils) GetNumberOfProposedBlocks(rpcParameters rpc.RPCParameters, epoch uint32) (uint8, error) { + ret := _m.Called(rpcParameters, epoch) var r0 uint8 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (uint8, error)); ok { - return rf(client, epoch) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) (uint8, error)); ok { + return rf(rpcParameters, epoch) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) uint8); ok { - r0 = rf(client, epoch) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) uint8); ok { + r0 = rf(rpcParameters, epoch) } else { r0 = ret.Get(0).(uint8) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { - r1 = rf(client, epoch) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, epoch) } else { r1 = ret.Error(1) } @@ -1178,23 +1350,23 @@ func (_m *Utils) GetNumberOfProposedBlocks(client *ethclient.Client, epoch uint3 return r0, r1 } -// GetNumberOfStakers provides a mock function with given fields: client -func (_m *Utils) GetNumberOfStakers(client *ethclient.Client) (uint32, error) { - ret := _m.Called(client) +// GetNumberOfStakers provides a mock function with given fields: rpcParameters +func (_m *Utils) GetNumberOfStakers(rpcParameters rpc.RPCParameters) (uint32, error) { + ret := _m.Called(rpcParameters) var r0 uint32 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint32, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (uint32, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) uint32); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) uint32); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -1216,23 +1388,23 @@ func (_m *Utils) GetOptions() bind.CallOpts { return r0 } -// GetProposedBlock provides a mock function with given fields: client, epoch, proposedBlockId -func (_m *Utils) GetProposedBlock(client *ethclient.Client, epoch uint32, proposedBlockId uint32) (bindings.StructsBlock, error) { - ret := _m.Called(client, epoch, proposedBlockId) +// GetProposedBlock provides a mock function with given fields: rpcParameters, epoch, proposedBlockId +func (_m *Utils) GetProposedBlock(rpcParameters rpc.RPCParameters, epoch uint32, proposedBlockId uint32) (bindings.StructsBlock, error) { + ret := _m.Called(rpcParameters, epoch, proposedBlockId) var r0 bindings.StructsBlock var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32) (bindings.StructsBlock, error)); ok { - return rf(client, epoch, proposedBlockId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint32) (bindings.StructsBlock, error)); ok { + return rf(rpcParameters, epoch, proposedBlockId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32) bindings.StructsBlock); ok { - r0 = rf(client, epoch, proposedBlockId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint32) bindings.StructsBlock); ok { + r0 = rf(rpcParameters, epoch, proposedBlockId) } else { r0 = ret.Get(0).(bindings.StructsBlock) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, uint32) error); ok { - r1 = rf(client, epoch, proposedBlockId) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32, uint32) error); ok { + r1 = rf(rpcParameters, epoch, proposedBlockId) } else { r1 = ret.Error(1) } @@ -1240,23 +1412,23 @@ func (_m *Utils) GetProposedBlock(client *ethclient.Client, epoch uint32, propos return r0, r1 } -// GetRemainingTimeOfCurrentState provides a mock function with given fields: client, bufferPercent -func (_m *Utils) GetRemainingTimeOfCurrentState(client *ethclient.Client, bufferPercent int32) (int64, error) { - ret := _m.Called(client, bufferPercent) +// GetRemainingTimeOfCurrentState provides a mock function with given fields: block, stateBuffer, bufferPercent +func (_m *Utils) GetRemainingTimeOfCurrentState(block *coretypes.Header, stateBuffer uint64, bufferPercent int32) (int64, error) { + ret := _m.Called(block, stateBuffer, bufferPercent) var r0 int64 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, int32) (int64, error)); ok { - return rf(client, bufferPercent) + if rf, ok := ret.Get(0).(func(*coretypes.Header, uint64, int32) (int64, error)); ok { + return rf(block, stateBuffer, bufferPercent) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, int32) int64); ok { - r0 = rf(client, bufferPercent) + if rf, ok := ret.Get(0).(func(*coretypes.Header, uint64, int32) int64); ok { + r0 = rf(block, stateBuffer, bufferPercent) } else { r0 = ret.Get(0).(int64) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, int32) error); ok { - r1 = rf(client, bufferPercent) + if rf, ok := ret.Get(1).(func(*coretypes.Header, uint64, int32) error); ok { + r1 = rf(block, stateBuffer, bufferPercent) } else { r1 = ret.Error(1) } @@ -1280,23 +1452,49 @@ func (_m *Utils) GetRogueRandomValue(value int) *big.Int { return r0 } -// GetSortedProposedBlockId provides a mock function with given fields: client, epoch, index -func (_m *Utils) GetSortedProposedBlockId(client *ethclient.Client, epoch uint32, index *big.Int) (uint32, error) { - ret := _m.Called(client, epoch, index) +// GetSaltFromBlockchain provides a mock function with given fields: rpcParameters +func (_m *Utils) GetSaltFromBlockchain(rpcParameters rpc.RPCParameters) ([32]byte, error) { + ret := _m.Called(rpcParameters) + + var r0 [32]byte + var r1 error + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) ([32]byte, error)); ok { + return rf(rpcParameters) + } + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) [32]byte); ok { + r0 = rf(rpcParameters) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([32]byte) + } + } + + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetSortedProposedBlockId provides a mock function with given fields: rpcParameters, epoch, index +func (_m *Utils) GetSortedProposedBlockId(rpcParameters rpc.RPCParameters, epoch uint32, index *big.Int) (uint32, error) { + ret := _m.Called(rpcParameters, epoch, index) var r0 uint32 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, *big.Int) (uint32, error)); ok { - return rf(client, epoch, index) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, *big.Int) (uint32, error)); ok { + return rf(rpcParameters, epoch, index) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, *big.Int) uint32); ok { - r0 = rf(client, epoch, index) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, *big.Int) uint32); ok { + r0 = rf(rpcParameters, epoch, index) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, *big.Int) error); ok { - r1 = rf(client, epoch, index) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32, *big.Int) error); ok { + r1 = rf(rpcParameters, epoch, index) } else { r1 = ret.Error(1) } @@ -1304,25 +1502,25 @@ func (_m *Utils) GetSortedProposedBlockId(client *ethclient.Client, epoch uint32 return r0, r1 } -// GetSortedProposedBlockIds provides a mock function with given fields: client, epoch -func (_m *Utils) GetSortedProposedBlockIds(client *ethclient.Client, epoch uint32) ([]uint32, error) { - ret := _m.Called(client, epoch) +// GetSortedProposedBlockIds provides a mock function with given fields: rpcParameters, epoch +func (_m *Utils) GetSortedProposedBlockIds(rpcParameters rpc.RPCParameters, epoch uint32) ([]uint32, error) { + ret := _m.Called(rpcParameters, epoch) var r0 []uint32 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) ([]uint32, error)); ok { - return rf(client, epoch) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) ([]uint32, error)); ok { + return rf(rpcParameters, epoch) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) []uint32); ok { - r0 = rf(client, epoch) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) []uint32); ok { + r0 = rf(rpcParameters, epoch) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]uint32) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { - r1 = rf(client, epoch) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, epoch) } else { r1 = ret.Error(1) } @@ -1330,25 +1528,25 @@ func (_m *Utils) GetSortedProposedBlockIds(client *ethclient.Client, epoch uint3 return r0, r1 } -// GetStake provides a mock function with given fields: client, stakerId -func (_m *Utils) GetStake(client *ethclient.Client, stakerId uint32) (*big.Int, error) { - ret := _m.Called(client, stakerId) +// GetStake provides a mock function with given fields: rpcParameters, stakerId +func (_m *Utils) GetStake(rpcParameters rpc.RPCParameters, stakerId uint32) (*big.Int, error) { + ret := _m.Called(rpcParameters, stakerId) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (*big.Int, error)); ok { - return rf(client, stakerId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) (*big.Int, error)); ok { + return rf(rpcParameters, stakerId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) *big.Int); ok { - r0 = rf(client, stakerId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) *big.Int); ok { + r0 = rf(rpcParameters, stakerId) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { - r1 = rf(client, stakerId) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, stakerId) } else { r1 = ret.Error(1) } @@ -1398,25 +1596,25 @@ func (_m *Utils) GetStakeManagerWithOpts(client *ethclient.Client) (*bindings.St return r0, r1 } -// GetStakeSnapshot provides a mock function with given fields: client, stakerId, epoch -func (_m *Utils) GetStakeSnapshot(client *ethclient.Client, stakerId uint32, epoch uint32) (*big.Int, error) { - ret := _m.Called(client, stakerId, epoch) +// GetStakeSnapshot provides a mock function with given fields: rpcParameters, stakerId, epoch +func (_m *Utils) GetStakeSnapshot(rpcParameters rpc.RPCParameters, stakerId uint32, epoch uint32) (*big.Int, error) { + ret := _m.Called(rpcParameters, stakerId, epoch) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32) (*big.Int, error)); ok { - return rf(client, stakerId, epoch) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint32) (*big.Int, error)); ok { + return rf(rpcParameters, stakerId, epoch) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32) *big.Int); ok { - r0 = rf(client, stakerId, epoch) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint32) *big.Int); ok { + r0 = rf(rpcParameters, stakerId, epoch) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, uint32) error); ok { - r1 = rf(client, stakerId, epoch) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32, uint32) error); ok { + r1 = rf(rpcParameters, stakerId, epoch) } else { r1 = ret.Error(1) } @@ -1466,23 +1664,23 @@ func (_m *Utils) GetStakedTokenManagerWithOpts(client *ethclient.Client, tokenAd return r0, r1 } -// GetStaker provides a mock function with given fields: client, stakerId -func (_m *Utils) GetStaker(client *ethclient.Client, stakerId uint32) (bindings.StructsStaker, error) { - ret := _m.Called(client, stakerId) +// GetStaker provides a mock function with given fields: rpcParameters, stakerId +func (_m *Utils) GetStaker(rpcParameters rpc.RPCParameters, stakerId uint32) (bindings.StructsStaker, error) { + ret := _m.Called(rpcParameters, stakerId) var r0 bindings.StructsStaker var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) (bindings.StructsStaker, error)); ok { - return rf(client, stakerId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) (bindings.StructsStaker, error)); ok { + return rf(rpcParameters, stakerId) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32) bindings.StructsStaker); ok { - r0 = rf(client, stakerId) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) bindings.StructsStaker); ok { + r0 = rf(rpcParameters, stakerId) } else { r0 = ret.Get(0).(bindings.StructsStaker) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32) error); ok { - r1 = rf(client, stakerId) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, stakerId) } else { r1 = ret.Error(1) } @@ -1490,23 +1688,23 @@ func (_m *Utils) GetStaker(client *ethclient.Client, stakerId uint32) (bindings. return r0, r1 } -// GetStakerId provides a mock function with given fields: client, address -func (_m *Utils) GetStakerId(client *ethclient.Client, address string) (uint32, error) { - ret := _m.Called(client, address) +// GetStakerId provides a mock function with given fields: rpcParameters, address +func (_m *Utils) GetStakerId(rpcParameters rpc.RPCParameters, address string) (uint32, error) { + ret := _m.Called(rpcParameters, address) var r0 uint32 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, string) (uint32, error)); ok { - return rf(client, address) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, string) (uint32, error)); ok { + return rf(rpcParameters, address) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, string) uint32); ok { - r0 = rf(client, address) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, string) uint32); ok { + r0 = rf(rpcParameters, address) } else { r0 = ret.Get(0).(uint32) } - if rf, ok := ret.Get(1).(func(*ethclient.Client, string) error); ok { - r1 = rf(client, address) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, string) error); ok { + r1 = rf(rpcParameters, address) } else { r1 = ret.Error(1) } @@ -1514,25 +1712,25 @@ func (_m *Utils) GetStakerId(client *ethclient.Client, address string) (uint32, return r0, r1 } -// GetStakerSRZRBalance provides a mock function with given fields: client, staker -func (_m *Utils) GetStakerSRZRBalance(client *ethclient.Client, staker bindings.StructsStaker) (*big.Int, error) { - ret := _m.Called(client, staker) +// GetStakerSRZRBalance provides a mock function with given fields: rpcParameters, staker +func (_m *Utils) GetStakerSRZRBalance(rpcParameters rpc.RPCParameters, staker bindings.StructsStaker) (*big.Int, error) { + ret := _m.Called(rpcParameters, staker) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, bindings.StructsStaker) (*big.Int, error)); ok { - return rf(client, staker) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, bindings.StructsStaker) (*big.Int, error)); ok { + return rf(rpcParameters, staker) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, bindings.StructsStaker) *big.Int); ok { - r0 = rf(client, staker) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, bindings.StructsStaker) *big.Int); ok { + r0 = rf(rpcParameters, staker) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, bindings.StructsStaker) error); ok { - r1 = rf(client, staker) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, bindings.StructsStaker) error); ok { + r1 = rf(rpcParameters, staker) } else { r1 = ret.Error(1) } @@ -1540,23 +1738,23 @@ func (_m *Utils) GetStakerSRZRBalance(client *ethclient.Client, staker bindings. return r0, r1 } -// GetStateBuffer provides a mock function with given fields: client -func (_m *Utils) GetStateBuffer(client *ethclient.Client) (uint64, error) { - ret := _m.Called(client) +// GetStateBuffer provides a mock function with given fields: rpcParameters +func (_m *Utils) GetStateBuffer(rpcParameters rpc.RPCParameters) (uint64, error) { + ret := _m.Called(rpcParameters) var r0 uint64 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint64, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (uint64, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) uint64); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) uint64); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(uint64) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -1580,25 +1778,25 @@ func (_m *Utils) GetTokenManager(client *ethclient.Client) *bindings.RAZOR { return r0 } -// GetTotalInfluenceRevealed provides a mock function with given fields: client, epoch, medianIndex -func (_m *Utils) GetTotalInfluenceRevealed(client *ethclient.Client, epoch uint32, medianIndex uint16) (*big.Int, error) { - ret := _m.Called(client, epoch, medianIndex) +// GetTotalInfluenceRevealed provides a mock function with given fields: rpcParameters, epoch, medianIndex +func (_m *Utils) GetTotalInfluenceRevealed(rpcParameters rpc.RPCParameters, epoch uint32, medianIndex uint16) (*big.Int, error) { + ret := _m.Called(rpcParameters, epoch, medianIndex) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint16) (*big.Int, error)); ok { - return rf(client, epoch, medianIndex) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint16) (*big.Int, error)); ok { + return rf(rpcParameters, epoch, medianIndex) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint16) *big.Int); ok { - r0 = rf(client, epoch, medianIndex) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint16) *big.Int); ok { + r0 = rf(rpcParameters, epoch, medianIndex) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, uint16) error); ok { - r1 = rf(client, epoch, medianIndex) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32, uint16) error); ok { + r1 = rf(rpcParameters, epoch, medianIndex) } else { r1 = ret.Error(1) } @@ -1606,20 +1804,30 @@ func (_m *Utils) GetTotalInfluenceRevealed(client *ethclient.Client, epoch uint3 return r0, r1 } -// GetTxnOpts provides a mock function with given fields: transactionData -func (_m *Utils) GetTxnOpts(transactionData types.TransactionOptions) *bind.TransactOpts { - ret := _m.Called(transactionData) +// GetTxnOpts provides a mock function with given fields: rpcParameters, transactionData +func (_m *Utils) GetTxnOpts(rpcParameters rpc.RPCParameters, transactionData types.TransactionOptions) (*bind.TransactOpts, error) { + ret := _m.Called(rpcParameters, transactionData) var r0 *bind.TransactOpts - if rf, ok := ret.Get(0).(func(types.TransactionOptions) *bind.TransactOpts); ok { - r0 = rf(transactionData) + var r1 error + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, types.TransactionOptions) (*bind.TransactOpts, error)); ok { + return rf(rpcParameters, transactionData) + } + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, types.TransactionOptions) *bind.TransactOpts); ok { + r0 = rf(rpcParameters, transactionData) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*bind.TransactOpts) } } - return r0 + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, types.TransactionOptions) error); ok { + r1 = rf(rpcParameters, transactionData) + } else { + r1 = ret.Error(1) + } + + return r0, r1 } // GetUint32 provides a mock function with given fields: flagSet, name @@ -1688,25 +1896,25 @@ func (_m *Utils) GetVoteManagerWithOpts(client *ethclient.Client) (*bindings.Vot return r0, r1 } -// GetVoteValue provides a mock function with given fields: client, epoch, stakerId, medianIndex -func (_m *Utils) GetVoteValue(client *ethclient.Client, epoch uint32, stakerId uint32, medianIndex uint16) (*big.Int, error) { - ret := _m.Called(client, epoch, stakerId, medianIndex) +// GetVoteValue provides a mock function with given fields: rpcParameters, epoch, stakerId, medianIndex +func (_m *Utils) GetVoteValue(rpcParameters rpc.RPCParameters, epoch uint32, stakerId uint32, medianIndex uint16) (*big.Int, error) { + ret := _m.Called(rpcParameters, epoch, stakerId, medianIndex) var r0 *big.Int var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32, uint16) (*big.Int, error)); ok { - return rf(client, epoch, stakerId, medianIndex) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint32, uint16) (*big.Int, error)); ok { + return rf(rpcParameters, epoch, stakerId, medianIndex) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, uint32, uint32, uint16) *big.Int); ok { - r0 = rf(client, epoch, stakerId, medianIndex) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32, uint32, uint16) *big.Int); ok { + r0 = rf(rpcParameters, epoch, stakerId, medianIndex) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*big.Int) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, uint32, uint32, uint16) error); ok { - r1 = rf(client, epoch, stakerId, medianIndex) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32, uint32, uint16) error); ok { + r1 = rf(rpcParameters, epoch, stakerId, medianIndex) } else { r1 = ret.Error(1) } @@ -1714,23 +1922,23 @@ func (_m *Utils) GetVoteValue(client *ethclient.Client, epoch uint32, stakerId u return r0, r1 } -// GetWithdrawInitiationPeriod provides a mock function with given fields: client -func (_m *Utils) GetWithdrawInitiationPeriod(client *ethclient.Client) (uint16, error) { - ret := _m.Called(client) +// GetWithdrawInitiationPeriod provides a mock function with given fields: rpcParameters +func (_m *Utils) GetWithdrawInitiationPeriod(rpcParameters rpc.RPCParameters) (uint16, error) { + ret := _m.Called(rpcParameters) var r0 uint16 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint16, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (uint16, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) uint16); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) uint16); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(uint16) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -1738,25 +1946,25 @@ func (_m *Utils) GetWithdrawInitiationPeriod(client *ethclient.Client) (uint16, return r0, r1 } -// HandleOfficialJobsFromJSONFile provides a mock function with given fields: client, collection, dataString, commitParams -func (_m *Utils) HandleOfficialJobsFromJSONFile(client *ethclient.Client, collection bindings.StructsCollection, dataString string, commitParams *types.CommitParams) ([]bindings.StructsJob, []uint16) { - ret := _m.Called(client, collection, dataString, commitParams) +// HandleOfficialJobsFromJSONFile provides a mock function with given fields: collection, dataString, commitParams +func (_m *Utils) HandleOfficialJobsFromJSONFile(collection bindings.StructsCollection, dataString string, commitParams *types.CommitParams) ([]bindings.StructsJob, []uint16) { + ret := _m.Called(collection, dataString, commitParams) var r0 []bindings.StructsJob var r1 []uint16 - if rf, ok := ret.Get(0).(func(*ethclient.Client, bindings.StructsCollection, string, *types.CommitParams) ([]bindings.StructsJob, []uint16)); ok { - return rf(client, collection, dataString, commitParams) + if rf, ok := ret.Get(0).(func(bindings.StructsCollection, string, *types.CommitParams) ([]bindings.StructsJob, []uint16)); ok { + return rf(collection, dataString, commitParams) } - if rf, ok := ret.Get(0).(func(*ethclient.Client, bindings.StructsCollection, string, *types.CommitParams) []bindings.StructsJob); ok { - r0 = rf(client, collection, dataString, commitParams) + if rf, ok := ret.Get(0).(func(bindings.StructsCollection, string, *types.CommitParams) []bindings.StructsJob); ok { + r0 = rf(collection, dataString, commitParams) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]bindings.StructsJob) } } - if rf, ok := ret.Get(1).(func(*ethclient.Client, bindings.StructsCollection, string, *types.CommitParams) []uint16); ok { - r1 = rf(client, collection, dataString, commitParams) + if rf, ok := ret.Get(1).(func(bindings.StructsCollection, string, *types.CommitParams) []uint16); ok { + r1 = rf(collection, dataString, commitParams) } else { if ret.Get(1) != nil { r1 = ret.Get(1).([]uint16) @@ -1880,23 +2088,47 @@ func (_m *Utils) SecondsToReadableTime(input int) string { return r0 } -// ToAssign provides a mock function with given fields: client -func (_m *Utils) ToAssign(client *ethclient.Client) (uint16, error) { - ret := _m.Called(client) +// StakerInfo provides a mock function with given fields: rpcParameters, stakerId +func (_m *Utils) StakerInfo(rpcParameters rpc.RPCParameters, stakerId uint32) (types.Staker, error) { + ret := _m.Called(rpcParameters, stakerId) + + var r0 types.Staker + var r1 error + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) (types.Staker, error)); ok { + return rf(rpcParameters, stakerId) + } + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, uint32) types.Staker); ok { + r0 = rf(rpcParameters, stakerId) + } else { + r0 = ret.Get(0).(types.Staker) + } + + if rf, ok := ret.Get(1).(func(rpc.RPCParameters, uint32) error); ok { + r1 = rf(rpcParameters, stakerId) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ToAssign provides a mock function with given fields: rpcParameters +func (_m *Utils) ToAssign(rpcParameters rpc.RPCParameters) (uint16, error) { + ret := _m.Called(rpcParameters) var r0 uint16 var r1 error - if rf, ok := ret.Get(0).(func(*ethclient.Client) (uint16, error)); ok { - return rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) (uint16, error)); ok { + return rf(rpcParameters) } - if rf, ok := ret.Get(0).(func(*ethclient.Client) uint16); ok { - r0 = rf(client) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters) uint16); ok { + r0 = rf(rpcParameters) } else { r0 = ret.Get(0).(uint16) } - if rf, ok := ret.Get(1).(func(*ethclient.Client) error); ok { - r1 = rf(client) + if rf, ok := ret.Get(1).(func(rpc.RPCParameters) error); ok { + r1 = rf(rpcParameters) } else { r1 = ret.Error(1) } @@ -1904,13 +2136,13 @@ func (_m *Utils) ToAssign(client *ethclient.Client) (uint16, error) { return r0, r1 } -// WaitForBlockCompletion provides a mock function with given fields: client, hashToRead -func (_m *Utils) WaitForBlockCompletion(client *ethclient.Client, hashToRead string) error { - ret := _m.Called(client, hashToRead) +// WaitForBlockCompletion provides a mock function with given fields: rpcManager, hashToRead +func (_m *Utils) WaitForBlockCompletion(rpcManager rpc.RPCParameters, hashToRead string) error { + ret := _m.Called(rpcManager, hashToRead) var r0 error - if rf, ok := ret.Get(0).(func(*ethclient.Client, string) error); ok { - r0 = rf(client, hashToRead) + if rf, ok := ret.Get(0).(func(rpc.RPCParameters, string) error); ok { + r0 = rf(rpcManager, hashToRead) } else { r0 = ret.Error(0) } diff --git a/utils/options.go b/utils/options.go index a92398895..a87c28204 100644 --- a/utils/options.go +++ b/utils/options.go @@ -4,12 +4,11 @@ import ( "context" "errors" "razor/core/types" + "razor/rpc" "strings" "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/ethclient" - "math/big" "github.com/ethereum/go-ethereum/accounts/abi/bind" @@ -25,45 +24,58 @@ func (*UtilsStruct) GetOptions() bind.CallOpts { } } -func (*UtilsStruct) GetTxnOpts(transactionData types.TransactionOptions) *bind.TransactOpts { +func (*UtilsStruct) GetTxnOpts(rpcParameters rpc.RPCParameters, transactionData types.TransactionOptions) (*bind.TransactOpts, error) { log.Debug("Getting transaction options...") account := transactionData.Account if account.AccountManager == nil { - log.Fatal("Account Manager in transaction data is not initialised") + log.Error("Account Manager in transaction data is not initialised") + return nil, errors.New("account manager not initialised") } privateKey, err := account.AccountManager.GetPrivateKey(account.Address, account.Password) - CheckError("Error in fetching private key: ", err) + if err != nil { + log.Error("Error in fetching private key: ", err) + return nil, err + } - nonce, err := ClientInterface.GetNonceAtWithRetry(transactionData.Client, common.HexToAddress(account.Address)) - CheckError("Error in fetching nonce: ", err) + nonce, err := ClientInterface.GetNonceAtWithRetry(rpcParameters, common.HexToAddress(account.Address)) + if err != nil { + log.Error("Error in fetching nonce: ", err) + return nil, err + } - gasPrice := GasInterface.GetGasPrice(transactionData.Client, transactionData.Config) + gasPrice := GasInterface.GetGasPrice(rpcParameters, transactionData.Config) txnOpts, err := BindInterface.NewKeyedTransactorWithChainID(privateKey, transactionData.ChainId) - CheckError("Error in getting transactor: ", err) + if err != nil { + log.Error("Error in getting transactor: ", err) + return nil, err + } txnOpts.Nonce = big.NewInt(int64(nonce)) txnOpts.GasPrice = gasPrice txnOpts.Value = transactionData.EtherValue - gasLimit, err := GasInterface.GetGasLimit(transactionData, txnOpts) + gasLimit, err := GasInterface.GetGasLimit(rpcParameters, transactionData, txnOpts) if err != nil { errString := err.Error() if ContainsStringFromArray(errString, []string{"500", "501", "502", "503", "504"}) || errString == errors.New("intrinsic gas too low").Error() { - latestBlock, err := ClientInterface.GetLatestBlockWithRetry(transactionData.Client) - CheckError("Error in fetching block: ", err) + latestBlock, err := ClientInterface.GetLatestBlockWithRetry(rpcParameters) + if err != nil { + log.Error("Error in fetching block: ", err) + return nil, err + } txnOpts.GasLimit = latestBlock.GasLimit log.Debug("Error occurred due to RPC issue, sending block gas limit...") log.Debug("Gas Limit: ", txnOpts.GasLimit) - return txnOpts + return txnOpts, nil } log.Error("Error in getting gas limit: ", err) } log.Debug("Gas after increment: ", gasLimit) txnOpts.GasLimit = gasLimit - return txnOpts + return txnOpts, nil } -func (*GasStruct) GetGasPrice(client *ethclient.Client, config types.Configurations) *big.Int { +func (*GasStruct) GetGasPrice(rpcParameters rpc.RPCParameters, config types.Configurations) *big.Int { var gas *big.Int if config.GasPrice != 0 { gas = big.NewInt(1).Mul(big.NewInt(int64(config.GasPrice)), big.NewInt(1e9)) @@ -71,7 +83,7 @@ func (*GasStruct) GetGasPrice(client *ethclient.Client, config types.Configurati gas = big.NewInt(0) } var err error - suggestedGasPrice, err := ClientInterface.SuggestGasPriceWithRetry(client) + suggestedGasPrice, err := ClientInterface.SuggestGasPriceWithRetry(rpcParameters) if err != nil { log.Error(err) return UtilsInterface.MultiplyFloatAndBigInt(gas, float64(config.GasMultiplier)) @@ -86,7 +98,7 @@ func (*GasStruct) GetGasPrice(client *ethclient.Client, config types.Configurati return gasPrice } -func (*GasStruct) GetGasLimit(transactionData types.TransactionOptions, txnOpts *bind.TransactOpts) (uint64, error) { +func (*GasStruct) GetGasLimit(rpcParameters rpc.RPCParameters, transactionData types.TransactionOptions, txnOpts *bind.TransactOpts) (uint64, error) { if transactionData.MethodName == "" { return 0, nil } @@ -110,14 +122,14 @@ func (*GasStruct) GetGasLimit(transactionData types.TransactionOptions, txnOpts } var gasLimit uint64 if transactionData.MethodName == "reveal" { - gasLimit, err = getGasLimitForReveal(transactionData.Client) + gasLimit, err = getGasLimitForReveal(rpcParameters) if err != nil { log.Error("GetGasLimit: Error in getting gasLimit for reveal transaction: ", err) return transactionData.Config.GasLimitOverride, err } log.Debug("Calculated gas limit for reveal: ", gasLimit) } else { - gasLimit, err = ClientInterface.EstimateGasWithRetry(transactionData.Client, msg) + gasLimit, err = ClientInterface.EstimateGasWithRetry(rpcParameters, msg) if err != nil { log.Error("GetGasLimit: Error in getting gasLimit: ", err) //If estimateGas throws an error for a transaction than gasLimit should be picked up from the config @@ -126,17 +138,17 @@ func (*GasStruct) GetGasLimit(transactionData types.TransactionOptions, txnOpts } log.Debug("Estimated Gas: ", gasLimit) } - return GasInterface.IncreaseGasLimitValue(transactionData.Client, gasLimit, transactionData.Config.GasLimitMultiplier) + return GasInterface.IncreaseGasLimitValue(rpcParameters, gasLimit, transactionData.Config.GasLimitMultiplier) } -func (*GasStruct) IncreaseGasLimitValue(client *ethclient.Client, gasLimit uint64, gasLimitMultiplier float32) (uint64, error) { +func (*GasStruct) IncreaseGasLimitValue(rpcParameters rpc.RPCParameters, gasLimit uint64, gasLimitMultiplier float32) (uint64, error) { if gasLimit == 0 || gasLimitMultiplier <= 0 { return gasLimit, nil } gasLimitIncremented := float64(gasLimitMultiplier) * float64(gasLimit) gasLimit = uint64(gasLimitIncremented) - latestBlock, err := ClientInterface.GetLatestBlockWithRetry(client) + latestBlock, err := ClientInterface.GetLatestBlockWithRetry(rpcParameters) if err != nil { log.Error("Error in fetching block: ", err) return 0, err @@ -149,8 +161,8 @@ func (*GasStruct) IncreaseGasLimitValue(client *ethclient.Client, gasLimit uint6 return gasLimit, nil } -func getGasLimitForReveal(client *ethclient.Client) (uint64, error) { - toAssign, err := UtilsInterface.ToAssign(client) +func getGasLimitForReveal(rpcParameters rpc.RPCParameters) (uint64, error) { + toAssign, err := UtilsInterface.ToAssign(rpcParameters) if err != nil { return 0, err } diff --git a/utils/options_test.go b/utils/options_test.go index 71628fbdd..909ec1bea 100644 --- a/utils/options_test.go +++ b/utils/options_test.go @@ -5,7 +5,6 @@ import ( "crypto/ecdsa" "crypto/rand" "errors" - "github.com/ethereum/go-ethereum/crypto" "math/big" "razor/accounts" "razor/core/types" @@ -14,16 +13,15 @@ import ( "strings" "testing" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" Types "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/mock" ) func Test_getGasPrice(t *testing.T) { - var client *ethclient.Client - type args struct { suggestedGasPrice *big.Int suggestedGasPriceErr error @@ -103,16 +101,16 @@ func Test_getGasPrice(t *testing.T) { }, } - defer func() { log.ExitFunc = nil }() + defer func() { log.LogrusInstance.ExitFunc = nil }() var fatal bool - log.ExitFunc = func(int) { fatal = true } + log.LogrusInstance.ExitFunc = func(int) { fatal = true } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { UtilsMock := new(mocks.Utils) clientUtilsMock := new(mocks.ClientUtils) - clientUtilsMock.On("SuggestGasPriceWithRetry", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.suggestedGasPrice, tt.args.suggestedGasPriceErr) + clientUtilsMock.On("SuggestGasPriceWithRetry", mock.Anything).Return(tt.args.suggestedGasPrice, tt.args.suggestedGasPriceErr) UtilsMock.On("MultiplyFloatAndBigInt", mock.AnythingOfType("*big.Int"), mock.AnythingOfType("float64")).Return(tt.args.multipliedGasPrice) fatal = false @@ -123,7 +121,7 @@ func Test_getGasPrice(t *testing.T) { } StartRazor(optionsPackageStruct) gasUtils := GasStruct{} - got := gasUtils.GetGasPrice(client, tt.args.config) + got := gasUtils.GetGasPrice(rpcParameters, tt.args.config) if fatal != tt.expectedFatal { if got.Cmp(tt.want) != 0 { t.Errorf("getGasPrice() = %v, want %v", got, tt.want) @@ -151,10 +149,10 @@ func Test_utils_GetTxnOpts(t *testing.T) { latestHeaderErr error } tests := []struct { - name string - args args - want *bind.TransactOpts - expectedFatal bool + name string + args args + want *bind.TransactOpts + wantErr bool }{ { name: "Test 1: When GetTxnOptions execute successfully", @@ -164,19 +162,17 @@ func Test_utils_GetTxnOpts(t *testing.T) { txnOpts: txnOpts, gasLimit: 1, }, - want: txnOpts, - expectedFatal: false, + want: txnOpts, + wantErr: false, }, { name: "Test 2: When there is an error in getting private key as address is not present in keystore", args: args{ - address: "0x77Baf83BAD5bee0F7F44d84669A50C35c57E3576", - nonce: 2, - txnOpts: txnOpts, - gasLimit: 1, + address: "0x77Baf83BAD5bee0F7F44d84669A50C35c57E3576", + nonce: 2, }, - want: txnOpts, - expectedFatal: true, + want: nil, + wantErr: true, }, { name: "Test 3: When the accountManager is nil", @@ -186,8 +182,8 @@ func Test_utils_GetTxnOpts(t *testing.T) { txnOpts: txnOpts, gasLimit: 1, }, - want: txnOpts, - expectedFatal: true, + want: nil, + wantErr: true, }, { name: "Test 4: When there is an error in getting nonce", @@ -198,8 +194,8 @@ func Test_utils_GetTxnOpts(t *testing.T) { txnOpts: txnOpts, gasLimit: 1, }, - want: txnOpts, - expectedFatal: true, + want: nil, + wantErr: true, }, { name: "Test 5: When there is an error in getting transactor", @@ -210,8 +206,8 @@ func Test_utils_GetTxnOpts(t *testing.T) { txnOptsErr: errors.New("transactor error"), gasLimit: 1, }, - want: txnOpts, - expectedFatal: true, + want: nil, + wantErr: true, }, { name: "Test 6: When there is an error in getting gasLimit", @@ -221,8 +217,8 @@ func Test_utils_GetTxnOpts(t *testing.T) { txnOpts: txnOpts, gasLimitErr: errors.New("gasLimit error"), }, - want: txnOpts, - expectedFatal: false, + want: txnOpts, + wantErr: false, }, { name: "Test 7: When there is an rpc error in getting gasLimit", @@ -235,8 +231,8 @@ func Test_utils_GetTxnOpts(t *testing.T) { GasLimit: 500, }, }, - want: txnOpts, - expectedFatal: false, + want: txnOpts, + wantErr: false, }, { name: "Test 8: When there is an rpc error in getting gasLimit and than error in getting latest header", @@ -250,21 +246,16 @@ func Test_utils_GetTxnOpts(t *testing.T) { }, latestHeaderErr: errors.New("latest header error"), }, - want: txnOpts, - expectedFatal: true, + want: nil, + wantErr: true, }, } - originalExitFunc := log.ExitFunc // Preserve the original ExitFunc - defer func() { log.ExitFunc = originalExitFunc }() // Ensure it's reset after tests + originalExitFunc := log.LogrusInstance.ExitFunc // Preserve the original ExitFunc + defer func() { log.LogrusInstance.ExitFunc = originalExitFunc }() // Ensure it's reset after tests for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - fatalOccurred := false - - // Override log.ExitFunc to induce a panic for testing the fatal scenario - log.ExitFunc = func(int) { panic("log.Fatal called") } - var account types.Account accountManager := accounts.NewAccountManager("test_accounts") if tt.args.address != "" { @@ -291,40 +282,20 @@ func Test_utils_GetTxnOpts(t *testing.T) { utils := StartRazor(optionsPackageStruct) - clientMock.On("GetNonceAtWithRetry", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("common.Address")).Return(tt.args.nonce, tt.args.nonceErr) - gasMock.On("GetGasPrice", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("types.Configurations")).Return(gasPrice) + clientMock.On("GetNonceAtWithRetry", mock.Anything, mock.Anything).Return(tt.args.nonce, tt.args.nonceErr) + gasMock.On("GetGasPrice", mock.Anything, mock.Anything).Return(gasPrice) bindMock.On("NewKeyedTransactorWithChainID", mock.AnythingOfType("*ecdsa.PrivateKey"), mock.AnythingOfType("*big.Int")).Return(tt.args.txnOpts, tt.args.txnOptsErr) - gasMock.On("GetGasLimit", transactionData, txnOpts).Return(tt.args.gasLimit, tt.args.gasLimitErr) - clientMock.On("SuggestGasPriceWithRetry", mock.AnythingOfType("*ethclient.Client")).Return(big.NewInt(1), nil) + gasMock.On("GetGasLimit", mock.Anything, transactionData, txnOpts).Return(tt.args.gasLimit, tt.args.gasLimitErr) utilsMock.On("MultiplyFloatAndBigInt", mock.AnythingOfType("*big.Int"), mock.AnythingOfType("float64")).Return(big.NewInt(1)) - clientMock.On("GetLatestBlockWithRetry", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.latestHeader, tt.args.latestHeaderErr) - - // Defer a function to recover from the panic and check if it matches the expectedFatal condition - defer func() { - if r := recover(); r != nil { - // A panic occurred, check if it was expected - if tt.expectedFatal { - // Panic (fatal) was expected and occurred, so this is correct - fatalOccurred = true - } else { - // Panic occurred but was not expected, fail the test - t.Errorf("Unexpected log.Fatal call") - } - } else { - // No panic occurred, check if it was expected - if tt.expectedFatal { - // Expected a fatal condition but it didn't occur, fail the test - t.Errorf("Expected log.Fatal call did not occur") - } - } - }() + clientMock.On("GetLatestBlockWithRetry", mock.Anything).Return(tt.args.latestHeader, tt.args.latestHeaderErr) - got := utils.GetTxnOpts(transactionData) - if !tt.expectedFatal && fatalOccurred { - t.Fatalf("Test exited due to an unexpected fatal condition") + got, err := utils.GetTxnOpts(rpcParameters, transactionData) + if (err != nil) != tt.wantErr { + t.Errorf("GetTxnOpts() error = %v, wantErr %v", err, tt.wantErr) + return } - if got != tt.want { - t.Errorf("GetTxnOpts() function, got = %v, want = %v", got, tt.want) + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetTxnOpts() got = %v, want %v", got, tt.want) } }) } @@ -480,12 +451,12 @@ func TestUtilsStruct_GetGasLimit(t *testing.T) { abiMock.On("Parse", reader).Return(tt.args.parsedData, tt.args.parseErr) abiMock.On("Pack", parsedData, mock.AnythingOfType("string"), mock.Anything).Return(tt.args.inputData, tt.args.packErr) - clientUtilsMock.On("EstimateGasWithRetry", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("ethereum.CallMsg")).Return(tt.args.gasLimit, tt.args.gasLimitErr) - gasUtilsMock.On("IncreaseGasLimitValue", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint64"), mock.AnythingOfType("float32")).Return(tt.args.increaseGasLimit, tt.args.increaseGasLimitErr) + clientUtilsMock.On("EstimateGasWithRetry", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.gasLimit, tt.args.gasLimitErr) + gasUtilsMock.On("IncreaseGasLimitValue", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.increaseGasLimit, tt.args.increaseGasLimitErr) utilsMock.On("ToAssign", mock.Anything).Return(tt.args.toAssign, tt.args.toAssignErr) gasUtils := GasStruct{} - got, err := gasUtils.GetGasLimit(tt.args.transactionData, txnOpts) + got, err := gasUtils.GetGasLimit(rpcParameters, tt.args.transactionData, txnOpts) if got != tt.want { t.Errorf("getGasLimit() got = %v, want %v", got, tt.want) } @@ -503,8 +474,6 @@ func TestUtilsStruct_GetGasLimit(t *testing.T) { } func TestUtilsStruct_IncreaseGasLimitValue(t *testing.T) { - var client *ethclient.Client - type args struct { gasLimit uint64 gasLimitMultiplier float32 @@ -580,10 +549,10 @@ func TestUtilsStruct_IncreaseGasLimitValue(t *testing.T) { StartRazor(optionsPackageStruct) - clientUtilsMock.On("GetLatestBlockWithRetry", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.latestBlock, tt.args.blockErr) + clientUtilsMock.On("GetLatestBlockWithRetry", mock.Anything, mock.Anything).Return(tt.args.latestBlock, tt.args.blockErr) gasUtils := GasStruct{} - got, err := gasUtils.IncreaseGasLimitValue(client, tt.args.gasLimit, tt.args.gasLimitMultiplier) + got, err := gasUtils.IncreaseGasLimitValue(rpcParameters, tt.args.gasLimit, tt.args.gasLimitMultiplier) if got != tt.want { t.Errorf("increaseGasLimitValue() got = %v, want %v", got, tt.want) } diff --git a/utils/stake.go b/utils/stake.go index 2e31ded35..4cb499b6b 100644 --- a/utils/stake.go +++ b/utils/stake.go @@ -4,6 +4,7 @@ import ( "math/big" "razor/core/types" "razor/pkg/bindings" + "razor/rpc" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" @@ -14,16 +15,16 @@ func (*UtilsStruct) GetStakeManagerWithOpts(client *ethclient.Client) (*bindings return UtilsInterface.GetStakeManager(client), UtilsInterface.GetOptions() } -func (*UtilsStruct) GetStakerId(client *ethclient.Client, address string) (uint32, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(StakeManagerInterface, "GetStakerId", client, common.HexToAddress(address)) +func (*UtilsStruct) GetStakerId(rpcParameters rpc.RPCParameters, address string) (uint32, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "GetStakerId", common.HexToAddress(address)) if err != nil { return 0, err } return returnedValues[0].Interface().(uint32), nil } -func (*UtilsStruct) GetStake(client *ethclient.Client, stakerId uint32) (*big.Int, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(StakeManagerInterface, "GetStaker", client, stakerId) +func (*UtilsStruct) GetStake(rpcParameters rpc.RPCParameters, stakerId uint32) (*big.Int, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "GetStaker", stakerId) if err != nil { return nil, err } @@ -31,62 +32,86 @@ func (*UtilsStruct) GetStake(client *ethclient.Client, stakerId uint32) (*big.In return staker.Stake, nil } -func (*UtilsStruct) GetStaker(client *ethclient.Client, stakerId uint32) (bindings.StructsStaker, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(StakeManagerInterface, "GetStaker", client, stakerId) +func (*UtilsStruct) GetStaker(rpcParameters rpc.RPCParameters, stakerId uint32) (bindings.StructsStaker, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "GetStaker", stakerId) if err != nil { return bindings.StructsStaker{}, err } return returnedValues[0].Interface().(bindings.StructsStaker), nil } -func (*UtilsStruct) GetNumberOfStakers(client *ethclient.Client) (uint32, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(StakeManagerInterface, "GetNumStakers", client) +func (*UtilsStruct) GetNumberOfStakers(rpcParameters rpc.RPCParameters) (uint32, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "GetNumStakers") if err != nil { return 0, err } return returnedValues[0].Interface().(uint32), nil } -func (*UtilsStruct) GetLock(client *ethclient.Client, address string, stakerId uint32, lockType uint8) (types.Locks, error) { - staker, err := UtilsInterface.GetStaker(client, stakerId) +func (*UtilsStruct) GetLock(rpcParameters rpc.RPCParameters, address string, stakerId uint32, lockType uint8) (types.Locks, error) { + staker, err := UtilsInterface.GetStaker(rpcParameters, stakerId) if err != nil { return types.Locks{}, err } - returnedValues, err := InvokeFunctionWithRetryAttempts(StakeManagerInterface, "Locks", client, common.HexToAddress(address), staker.TokenAddress, lockType) + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "Locks", common.HexToAddress(address), staker.TokenAddress, lockType) if err != nil { return types.Locks{}, err } return returnedValues[0].Interface().(types.Locks), nil } -func (*UtilsStruct) GetWithdrawInitiationPeriod(client *ethclient.Client) (uint16, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(StakeManagerInterface, "WithdrawInitiationPeriod", client) +func (*UtilsStruct) GetWithdrawInitiationPeriod(rpcParameters rpc.RPCParameters) (uint16, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "WithdrawInitiationPeriod") if err != nil { return 0, err } return returnedValues[0].Interface().(uint16), nil } -func (*UtilsStruct) GetMaxCommission(client *ethclient.Client) (uint8, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(StakeManagerInterface, "MaxCommission", client) +func (*UtilsStruct) GetMaxCommission(rpcParameters rpc.RPCParameters) (uint8, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "MaxCommission") if err != nil { return 0, err } return returnedValues[0].Interface().(uint8), nil } -func (*UtilsStruct) GetEpochLimitForUpdateCommission(client *ethclient.Client) (uint16, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(StakeManagerInterface, "EpochLimitForUpdateCommission", client) +func (*UtilsStruct) GetEpochLimitForUpdateCommission(rpcParameters rpc.RPCParameters) (uint16, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "EpochLimitForUpdateCommission") if err != nil { return 0, err } return returnedValues[0].Interface().(uint16), nil } -func (*UtilsStruct) GetMinSafeRazor(client *ethclient.Client) (*big.Int, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(StakeManagerInterface, "MinSafeRazor", client) +func (*UtilsStruct) GetMinSafeRazor(rpcParameters rpc.RPCParameters) (*big.Int, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "MinSafeRazor") if err != nil { return nil, err } return returnedValues[0].Interface().(*big.Int), nil } + +func (*UtilsStruct) StakerInfo(rpcParameters rpc.RPCParameters, stakerId uint32) (types.Staker, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "StakerInfo", stakerId) + if err != nil { + return types.Staker{}, err + } + return returnedValues[0].Interface().(types.Staker), nil +} + +func (*UtilsStruct) GetMaturity(rpcParameters rpc.RPCParameters, age uint32) (uint16, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "GetMaturity", age) + if err != nil { + return 0, err + } + return returnedValues[0].Interface().(uint16), nil +} + +func (*UtilsStruct) GetBountyLock(rpcParameters rpc.RPCParameters, bountyId uint32) (types.BountyLock, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakeManagerInterface, "GetBountyLock", bountyId) + if err != nil { + return types.BountyLock{}, err + } + return returnedValues[0].Interface().(types.BountyLock), nil +} diff --git a/utils/stake_test.go b/utils/stake_test.go index 142fde453..6f02cae73 100644 --- a/utils/stake_test.go +++ b/utils/stake_test.go @@ -2,6 +2,7 @@ package utils import ( "errors" + "github.com/ethereum/go-ethereum/common" "math/big" "razor/core/types" "razor/pkg/bindings" @@ -16,7 +17,6 @@ import ( ) func TestGetEpochLimitForUpdateCommission(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts type args struct { @@ -63,7 +63,7 @@ func TestGetEpochLimitForUpdateCommission(t *testing.T) { stakeManagerMock.On("EpochLimitForUpdateCommission", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epochLimitForUpdateCommission, tt.args.epochLimitForUpdateCommissionErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetEpochLimitForUpdateCommission(client) + got, err := utils.GetEpochLimitForUpdateCommission(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetEpochLimitForUpdateCommission() error = %v, wantErr %v", err, tt.wantErr) return @@ -77,7 +77,6 @@ func TestGetEpochLimitForUpdateCommission(t *testing.T) { func TestGetLock(t *testing.T) { var ( - client *ethclient.Client address string stakerId uint32 lockType uint8 @@ -135,11 +134,11 @@ func TestGetLock(t *testing.T) { } utils := StartRazor(optionsPackageStruct) - utilsMock.On("GetStaker", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.staker, tt.args.stakerErr) + utilsMock.On("GetStaker", mock.Anything, mock.Anything).Return(tt.args.staker, tt.args.stakerErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) stakeManagerMock.On("Locks", mock.AnythingOfType("*ethclient.Client"), mock.Anything, mock.Anything, mock.AnythingOfType("uint8")).Return(tt.args.locks, tt.args.locksErr) - got, err := utils.GetLock(client, address, stakerId, lockType) + got, err := utils.GetLock(rpcParameters, address, stakerId, lockType) if (err != nil) != tt.wantErr { t.Errorf("GetLock() error = %v, wantErr %v", err, tt.wantErr) return @@ -152,8 +151,6 @@ func TestGetLock(t *testing.T) { } func TestGetMaxCommission(t *testing.T) { - var client *ethclient.Client - type args struct { maxCommission uint8 maxCommissionErr error @@ -197,7 +194,7 @@ func TestGetMaxCommission(t *testing.T) { stakeManagerMock.On("MaxCommission", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.maxCommission, tt.args.maxCommissionErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetMaxCommission(client) + got, err := utils.GetMaxCommission(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetMaxCommission() error = %v, wantErr %v", err, tt.wantErr) return @@ -210,8 +207,6 @@ func TestGetMaxCommission(t *testing.T) { } func TestGetNumberOfStakers(t *testing.T) { - var client *ethclient.Client - type args struct { numStakers uint32 numStakersErr error @@ -255,7 +250,7 @@ func TestGetNumberOfStakers(t *testing.T) { stakeManagerMock.On("GetNumStakers", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.numStakers, tt.args.numStakersErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetNumberOfStakers(client) + got, err := utils.GetNumberOfStakers(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetNumberOfStakers() error = %v, wantErr %v", err, tt.wantErr) return @@ -268,7 +263,6 @@ func TestGetNumberOfStakers(t *testing.T) { } func TestGetStake(t *testing.T) { - var client *ethclient.Client var stakerId uint32 type args struct { @@ -314,7 +308,7 @@ func TestGetStake(t *testing.T) { stakeManagerMock.On("GetStaker", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.staker, tt.args.stakerErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetStake(client, stakerId) + got, err := utils.GetStake(rpcParameters, stakerId) if (err != nil) != tt.wantErr { t.Errorf("GetStake() error = %v, wantErr %v", err, tt.wantErr) return @@ -327,7 +321,6 @@ func TestGetStake(t *testing.T) { } func TestGetStaker(t *testing.T) { - var client *ethclient.Client var stakerId uint32 type args struct { @@ -373,7 +366,7 @@ func TestGetStaker(t *testing.T) { stakeManagerMock.On("GetStaker", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.staker, tt.args.stakerErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetStaker(client, stakerId) + got, err := utils.GetStaker(rpcParameters, stakerId) if (err != nil) != tt.wantErr { t.Errorf("GetStaker() error = %v, wantErr %v", err, tt.wantErr) return @@ -386,7 +379,6 @@ func TestGetStaker(t *testing.T) { } func TestGetStakerId(t *testing.T) { - var client *ethclient.Client var account string type args struct { @@ -432,7 +424,7 @@ func TestGetStakerId(t *testing.T) { stakeManagerMock.On("GetStakerId", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetStakerId(client, account) + got, err := utils.GetStakerId(rpcParameters, account) if (err != nil) != tt.wantErr { t.Errorf("GetStakerId() error = %v, wantErr %v", err, tt.wantErr) return @@ -445,8 +437,6 @@ func TestGetStakerId(t *testing.T) { } func TestGetWithdrawReleasePeriod(t *testing.T) { - var client *ethclient.Client - type args struct { withdrawReleasePeriod uint16 withdrawReleasePeriodErr error @@ -490,7 +480,7 @@ func TestGetWithdrawReleasePeriod(t *testing.T) { stakeManagerMock.On("WithdrawInitiationPeriod", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.withdrawReleasePeriod, tt.args.withdrawReleasePeriodErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetWithdrawInitiationPeriod(client) + got, err := utils.GetWithdrawInitiationPeriod(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetWithdrawInitiationPeriod() error = %v, wantErr %v", err, tt.wantErr) return @@ -527,7 +517,6 @@ func TestGetStakeManagerWithOpts(t *testing.T) { } func TestGetMinSafeRazor(t *testing.T) { - var client *ethclient.Client type args struct { minSafeRazor *big.Int minSafeRazorErr error @@ -569,7 +558,7 @@ func TestGetMinSafeRazor(t *testing.T) { stakeManagerMock.On("MinSafeRazor", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.minSafeRazor, tt.args.minSafeRazorErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetMinSafeRazor(client) + got, err := utils.GetMinSafeRazor(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("GetMinSafeRazor() error = %v, wantErr %v", err, tt.wantErr) return @@ -580,3 +569,173 @@ func TestGetMinSafeRazor(t *testing.T) { }) } } + +func TestStakerInfo(t *testing.T) { + type args struct { + staker types.Staker + stakerErr error + } + tests := []struct { + name string + args args + want types.Staker + wantErr bool + }{ + { + name: "Test 1: When StakerInfo() executes successfully", + args: args{ + staker: types.Staker{ + Id: 1, + }, + }, + want: types.Staker{ + Id: 1, + }, + wantErr: false, + }, + { + name: "Test 2: When there is an error in getting staker info", + args: args{ + stakerErr: errors.New("staker info error"), + }, + want: types.Staker{}, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + retryMock := new(mocks.RetryUtils) + stakeManagerMock := new(mocks.StakeManagerUtils) + + optionsPackageStruct := OptionsPackageStruct{ + RetryInterface: retryMock, + StakeManagerInterface: stakeManagerMock, + } + utils := StartRazor(optionsPackageStruct) + + stakeManagerMock.On("StakerInfo", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.staker, tt.args.stakerErr) + retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) + + got, err := utils.StakerInfo(rpcParameters, 1) + if (err != nil) != tt.wantErr { + t.Errorf("StakerInfo() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("StakerInfo() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestGetMaturity(t *testing.T) { + type args struct { + maturity uint16 + maturityErr error + } + tests := []struct { + name string + args args + want uint16 + wantErr bool + }{ + { + name: "Test 1: When GetMaturity() executes successfully", + args: args{ + maturity: 100, + }, + want: 100, + wantErr: false, + }, + { + name: "Test 2: When there is an error in getting maturity", + args: args{ + maturityErr: errors.New("maturity error"), + }, + want: 0, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + retryMock := new(mocks.RetryUtils) + stakeManagerMock := new(mocks.StakeManagerUtils) + + optionsPackageStruct := OptionsPackageStruct{ + RetryInterface: retryMock, + StakeManagerInterface: stakeManagerMock, + } + utils := StartRazor(optionsPackageStruct) + + stakeManagerMock.On("GetMaturity", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.maturity, tt.args.maturityErr) + retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) + + got, err := utils.GetMaturity(rpcParameters, 10) + if (err != nil) != tt.wantErr { + t.Errorf("GetMaturity() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("GetMaturity() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestGetBountyLock(t *testing.T) { + type args struct { + bountyLock types.BountyLock + bountyLockErr error + } + tests := []struct { + name string + args args + want types.BountyLock + wantErr bool + }{ + { + name: "Test 1: When GetBountyLock() executes successfully", + args: args{ + bountyLock: types.BountyLock{ + BountyHunter: common.HexToAddress("0xaA"), + }, + }, + want: types.BountyLock{ + BountyHunter: common.HexToAddress("0xaA"), + }, + wantErr: false, + }, + { + name: "Test 2: When there is an error in getting bounty lock", + args: args{ + bountyLockErr: errors.New("bounty lock error"), + }, + want: types.BountyLock{}, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + retryMock := new(mocks.RetryUtils) + stakeManagerMock := new(mocks.StakeManagerUtils) + + optionsPackageStruct := OptionsPackageStruct{ + RetryInterface: retryMock, + StakeManagerInterface: stakeManagerMock, + } + utils := StartRazor(optionsPackageStruct) + + stakeManagerMock.On("GetBountyLock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.bountyLock, tt.args.bountyLockErr) + retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) + + got, err := utils.GetBountyLock(rpcParameters, 1) + if (err != nil) != tt.wantErr { + t.Errorf("GetBountyLock() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetBountyLock() got = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/utils/stakedToken.go b/utils/stakedToken.go index 9b0b69088..3546c15a8 100644 --- a/utils/stakedToken.go +++ b/utils/stakedToken.go @@ -6,14 +6,15 @@ import ( "github.com/ethereum/go-ethereum/ethclient" "math/big" "razor/pkg/bindings" + "razor/rpc" ) func (*UtilsStruct) GetStakedTokenManagerWithOpts(client *ethclient.Client, tokenAddress common.Address) (*bindings.StakedToken, bind.CallOpts) { return UtilsInterface.GetStakedToken(client, tokenAddress), UtilsInterface.GetOptions() } -func (*UtilsStruct) GetStakerSRZRBalance(client *ethclient.Client, staker bindings.StructsStaker) (*big.Int, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(StakedTokenInterface, "BalanceOf", client, staker.TokenAddress, staker.Address) +func (*UtilsStruct) GetStakerSRZRBalance(rpcParameters rpc.RPCParameters, staker bindings.StructsStaker) (*big.Int, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, StakedTokenInterface, "BalanceOf", staker.TokenAddress, staker.Address) if err != nil { log.Error("Error in getting sRZRBalance: ", err) return nil, err diff --git a/utils/stakedToken_test.go b/utils/stakedToken_test.go index 4440e9d0d..5fe5d9842 100644 --- a/utils/stakedToken_test.go +++ b/utils/stakedToken_test.go @@ -3,7 +3,6 @@ package utils import ( "errors" "github.com/avast/retry-go" - "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/mock" "math/big" "razor/pkg/bindings" @@ -13,11 +12,7 @@ import ( ) func TestGetStakerSRZRBalance(t *testing.T) { - var ( - client *ethclient.Client - staker bindings.StructsStaker - ) - + var staker bindings.StructsStaker type args struct { sRZR *big.Int sRZRErr error @@ -61,7 +56,7 @@ func TestGetStakerSRZRBalance(t *testing.T) { stakedTokenMock.On("BalanceOf", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.sRZR, tt.args.sRZRErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetStakerSRZRBalance(client, staker) + got, err := utils.GetStakerSRZRBalance(rpcParameters, staker) if (err != nil) != tt.wantErr { t.Errorf("GetStakerSRZRBalance() error = %v, wantErr %v", err, tt.wantErr) return diff --git a/utils/struct-utils.go b/utils/struct-utils.go index 654bca816..839e78554 100644 --- a/utils/struct-utils.go +++ b/utils/struct-utils.go @@ -9,12 +9,13 @@ import ( "io/fs" "math/big" "os" - "razor/client" "razor/core" coretypes "razor/core/types" "razor/path" "razor/pkg/bindings" + "razor/rpc" "reflect" + "strings" "time" "github.com/avast/retry-go" @@ -110,42 +111,112 @@ func CheckIfAnyError(result []reflect.Value) error { return nil } -func InvokeFunctionWithRetryAttempts(interfaceName interface{}, methodName string, args ...interface{}) ([]reflect.Value, error) { +func InvokeFunctionWithRetryAttempts(rpcParameters rpc.RPCParameters, interfaceName interface{}, methodName string, args ...interface{}) ([]reflect.Value, error) { var returnedValues []reflect.Value var err error - inputs := make([]reflect.Value, len(args)) - for i := range args { - inputs[i] = reflect.ValueOf(args[i]) + var contextError bool + + // Ensure inputs has space for the client and any additional arguments + inputs := make([]reflect.Value, len(args)+1) + + // Always use the current best client for each retry + client, err := rpcParameters.RPCManager.GetBestRPCClient() + if err != nil { + log.Errorf("Failed to get current best client: %v", err) + return returnedValues, err } - alternateProvider := client.GetAlternateProvider() - switchToAlternateClient := client.GetSwitchToAlternateClientStatus() - if switchToAlternateClient && alternateProvider != "" { - // Changing client argument to alternate client - log.Debug("Making this RPC call using alternate RPC provider!") - inputs = client.ReplaceClientWithAlternateClient(inputs) + + // Set the client as the first argument + inputs[0] = reflect.ValueOf(client) + // Add the rest of the args to inputs starting from index 1 + for i := 0; i < len(args); i++ { + inputs[i+1] = reflect.ValueOf(args[i]) } + err = retry.Do( func() error { - returnedValues = reflect.ValueOf(interfaceName).MethodByName(methodName).Call(inputs) - err = CheckIfAnyError(returnedValues) - if err != nil { - log.Debug("Function to retry: ", methodName) - log.Errorf("Error in %v....Retrying", methodName) - return err + // Check if the context has been cancelled or timed out + select { + case <-rpcParameters.Ctx.Done(): + // If context is done, return the context error timeout + log.Debugf("Context timed out for method: %s", methodName) + contextError = true + return retry.Unrecoverable(rpcParameters.Ctx.Err()) + default: + // Proceed with the RPC call + returnedValues = reflect.ValueOf(interfaceName).MethodByName(methodName).Call(inputs) + err = CheckIfAnyError(returnedValues) + if err != nil { + log.Debug("Function to retry: ", methodName) + log.Errorf("Error in %v....Retrying", methodName) + return err + } + return nil } - return nil }, RetryInterface.RetryAttempts(core.MaxRetries), retry.Delay(time.Second*time.Duration(core.RetryDelayDuration)), retry.DelayType(retry.FixedDelay)) if err != nil { - if !switchToAlternateClient && alternateProvider != "" { + if contextError { + // If context error, we don't switch the client + log.Warnf("Skipping switching to the next best client due to context error: %v", err) + return returnedValues, err + } + + // Only switch to the next best client if the error is identified as an RPC error + if isRPCError(err) { log.Errorf("%v error after retries: %v", methodName, err) - log.Info("Switching RPC to alternate RPC") - client.SetSwitchToAlternateClientStatus(true) - go client.StartTimerForAlternateClient(core.SwitchClientDuration) + log.Info("Attempting to switch to a new best RPC endpoint...") + + switched, switchErr := rpcParameters.RPCManager.SwitchToNextBestRPCClient() + if switchErr != nil { + log.Errorf("Failed to switch to the next best client: %v", switchErr) + return returnedValues, switchErr + } + + if switched { + log.Infof("Successfully switched to a new RPC endpoint after RPC error.") + } else { + log.Warnf("No switch occurred. Retaining the current RPC client.") + } } } + return returnedValues, err } +func isRPCError(err error) bool { + // Check for common RPC error patterns + if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) { + return true + } + + // Add other checks based on specific RPC errors (timeouts, connection issues, etc.) + if strings.Contains(err.Error(), "connection refused") || + strings.Contains(err.Error(), "connection reset by peer") || + strings.Contains(err.Error(), "EOF") || + strings.Contains(err.Error(), "dial") || + strings.Contains(err.Error(), "no such host") || + strings.Contains(err.Error(), "i/o timeout") { + return true + } + + // Check for HTTP 500–504 errors + if strings.Contains(err.Error(), "500") || + strings.Contains(err.Error(), "501") || + strings.Contains(err.Error(), "502") || + strings.Contains(err.Error(), "503") || + strings.Contains(err.Error(), "504") { + return true + } + + // Check for the custom RPC timeout error + if strings.Contains(err.Error(), "RPC timeout error") { + return true + } + + // If it's not an RPC error, return false + return false +} + func (b BlockManagerStruct) GetBlockIndexToBeConfirmed(client *ethclient.Client) (int8, error) { blockManager, opts := UtilsInterface.GetBlockManagerWithOpts(client) returnedValues := InvokeFunctionWithTimeout(blockManager, "BlockIndexToBeConfirmed", &opts) @@ -326,6 +397,37 @@ func (b BlockManagerStruct) GetEpochLastProposed(client *ethclient.Client, stake return returnedValues[0].Interface().(uint32), nil } +func (b BlockManagerStruct) GetConfirmedBlocks(client *ethclient.Client, epoch uint32) (coretypes.ConfirmedBlock, error) { + blockManager, opts := UtilsInterface.GetBlockManagerWithOpts(client) + returnedValues := InvokeFunctionWithTimeout(blockManager, "Blocks", &opts, epoch) + returnedError := CheckIfAnyError(returnedValues) + if returnedError != nil { + return coretypes.ConfirmedBlock{}, returnedError + } + return returnedValues[0].Interface().(struct { + Valid bool + ProposerId uint32 + Iteration *big.Int + BiggestStake *big.Int + }), nil +} + +func (b BlockManagerStruct) Disputes(client *ethclient.Client, epoch uint32, address common.Address) (coretypes.DisputesStruct, error) { + blockManager, opts := UtilsInterface.GetBlockManagerWithOpts(client) + returnedValues := InvokeFunctionWithTimeout(blockManager, "Disputes", &opts, epoch, address) + returnedError := CheckIfAnyError(returnedValues) + if returnedError != nil { + return coretypes.DisputesStruct{}, returnedError + } + disputesMapping := returnedValues[0].Interface().(struct { + LeafId uint16 + LastVisitedValue *big.Int + AccWeight *big.Int + Median *big.Int + }) + return disputesMapping, nil +} + func (s StakeManagerStruct) GetStakerId(client *ethclient.Client, address common.Address) (uint32, error) { stakeManager, opts := UtilsInterface.GetStakeManagerWithOpts(client) returnedValues := InvokeFunctionWithTimeout(stakeManager, "GetStakerId", &opts, address) @@ -400,6 +502,55 @@ func (s StakeManagerStruct) GetStaker(client *ethclient.Client, stakerId uint32) return returnedValues[0].Interface().(bindings.StructsStaker), nil } +func (s StakeManagerStruct) StakerInfo(client *ethclient.Client, stakerId uint32) (coretypes.Staker, error) { + stakeManager, opts := UtilsInterface.GetStakeManagerWithOpts(client) + returnedValues := InvokeFunctionWithTimeout(stakeManager, "Stakers", &opts, stakerId) + returnedError := CheckIfAnyError(returnedValues) + if returnedError != nil { + return coretypes.Staker{}, returnedError + } + staker := returnedValues[0].Interface().(struct { + AcceptDelegation bool + IsSlashed bool + Commission uint8 + Id uint32 + Age uint32 + Address common.Address + TokenAddress common.Address + EpochFirstStakedOrLastPenalized uint32 + EpochCommissionLastUpdated uint32 + Stake *big.Int + StakerReward *big.Int + }) + return staker, nil +} + +func (s StakeManagerStruct) GetMaturity(client *ethclient.Client, age uint32) (uint16, error) { + stakeManager, opts := UtilsInterface.GetStakeManagerWithOpts(client) + index := age / 10000 + returnedValues := InvokeFunctionWithTimeout(stakeManager, "Maturities", opts, big.NewInt(int64(index))) + returnedError := CheckIfAnyError(returnedValues) + if returnedError != nil { + return 0, returnedError + } + return returnedValues[0].Interface().(uint16), nil +} + +func (s StakeManagerStruct) GetBountyLock(client *ethclient.Client, bountyId uint32) (coretypes.BountyLock, error) { + stakeManager, opts := UtilsInterface.GetStakeManagerWithOpts(client) + returnedValues := InvokeFunctionWithTimeout(stakeManager, "BountyLocks", &opts, bountyId) + returnedError := CheckIfAnyError(returnedValues) + if returnedError != nil { + return coretypes.BountyLock{}, returnedError + } + bountyLock := returnedValues[0].Interface().(struct { + RedeemAfter uint32 + BountyHunter common.Address + Amount *big.Int + }) + return bountyLock, nil +} + func (a AssetManagerStruct) GetNumCollections(client *ethclient.Client) (uint16, error) { collectionManager, opts := UtilsInterface.GetCollectionManagerWithOpts(client) returnedValues := InvokeFunctionWithTimeout(collectionManager, "GetNumCollections", &opts) @@ -430,6 +581,16 @@ func (a AssetManagerStruct) GetActiveCollections(client *ethclient.Client) ([]ui return returnedValues[0].Interface().([]uint16), nil } +func (a AssetManagerStruct) GetActiveStatus(client *ethclient.Client, id uint16) (bool, error) { + collectionManager, opts := UtilsInterface.GetCollectionManagerWithOpts(client) + returnedValues := InvokeFunctionWithTimeout(collectionManager, "GetCollectionStatus", &opts, id) + returnedError := CheckIfAnyError(returnedValues) + if returnedError != nil { + return false, returnedError + } + return returnedValues[0].Interface().(bool), nil +} + func (a AssetManagerStruct) Jobs(client *ethclient.Client, id uint16) (bindings.StructsJob, error) { collectionManager, opts := UtilsInterface.GetCollectionManagerWithOpts(client) returnedValues := InvokeFunctionWithTimeout(collectionManager, "Jobs", &opts, id) @@ -661,8 +822,22 @@ func (c ClientStruct) FilterLogs(client *ethclient.Client, ctx context.Context, return returnedValues[0].Interface().([]types.Log), nil } -func (c CoinStruct) BalanceOf(erc20Contract *bindings.RAZOR, opts *bind.CallOpts, account common.Address) (*big.Int, error) { - returnedValues := InvokeFunctionWithTimeout(erc20Contract, "BalanceOf", opts, account) +func (c CoinStruct) BalanceOf(client *ethclient.Client, account common.Address) (*big.Int, error) { + tokenManager := UtilsInterface.GetTokenManager(client) + opts := UtilsInterface.GetOptions() + returnedValues := InvokeFunctionWithTimeout(tokenManager, "BalanceOf", &opts, account) + returnedError := CheckIfAnyError(returnedValues) + if returnedError != nil { + return nil, returnedError + } + return returnedValues[0].Interface().(*big.Int), nil +} + +//This function is used to check the allowance of staker +func (c CoinStruct) Allowance(client *ethclient.Client, owner common.Address, spender common.Address) (*big.Int, error) { + tokenManager := UtilsInterface.GetTokenManager(client) + opts := UtilsInterface.GetOptions() + returnedValues := InvokeFunctionWithTimeout(tokenManager, "Allowance", &opts, owner, spender) returnedError := CheckIfAnyError(returnedValues) if returnedError != nil { return nil, returnedError diff --git a/utils/vote.go b/utils/vote.go index b5d2f0616..dd7594686 100644 --- a/utils/vote.go +++ b/utils/vote.go @@ -4,6 +4,7 @@ import ( "math/big" "razor/core/types" "razor/pkg/bindings" + "razor/rpc" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/ethclient" @@ -13,12 +14,12 @@ func (*UtilsStruct) GetVoteManagerWithOpts(client *ethclient.Client) (*bindings. return UtilsInterface.GetVoteManager(client), UtilsInterface.GetOptions() } -func (*UtilsStruct) GetCommitment(client *ethclient.Client, address string) (types.Commitment, error) { - stakerId, err := UtilsInterface.GetStakerId(client, address) +func (*UtilsStruct) GetCommitment(rpcParameters rpc.RPCParameters, address string) (types.Commitment, error) { + stakerId, err := UtilsInterface.GetStakerId(rpcParameters, address) if err != nil { return types.Commitment{}, err } - returnedValues, err := InvokeFunctionWithRetryAttempts(VoteManagerInterface, "GetCommitment", client, stakerId) + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, VoteManagerInterface, "GetCommitment", stakerId) if err != nil { return types.Commitment{}, err } @@ -26,58 +27,66 @@ func (*UtilsStruct) GetCommitment(client *ethclient.Client, address string) (typ return commitment, nil } -func (*UtilsStruct) GetVoteValue(client *ethclient.Client, epoch uint32, stakerId uint32, medianIndex uint16) (*big.Int, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(VoteManagerInterface, "GetVoteValue", client, epoch, stakerId, medianIndex) +func (*UtilsStruct) GetVoteValue(rpcParameters rpc.RPCParameters, epoch uint32, stakerId uint32, medianIndex uint16) (*big.Int, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, VoteManagerInterface, "GetVoteValue", epoch, stakerId, medianIndex) if err != nil { return big.NewInt(0), err } return returnedValues[0].Interface().(*big.Int), nil } -func (*UtilsStruct) GetInfluenceSnapshot(client *ethclient.Client, stakerId uint32, epoch uint32) (*big.Int, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(VoteManagerInterface, "GetInfluenceSnapshot", client, epoch, stakerId) +func (*UtilsStruct) GetInfluenceSnapshot(rpcParameters rpc.RPCParameters, stakerId uint32, epoch uint32) (*big.Int, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, VoteManagerInterface, "GetInfluenceSnapshot", epoch, stakerId) if err != nil { return nil, err } return returnedValues[0].Interface().(*big.Int), nil } -func (*UtilsStruct) GetStakeSnapshot(client *ethclient.Client, stakerId uint32, epoch uint32) (*big.Int, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(VoteManagerInterface, "GetStakeSnapshot", client, epoch, stakerId) +func (*UtilsStruct) GetStakeSnapshot(rpcParameters rpc.RPCParameters, stakerId uint32, epoch uint32) (*big.Int, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, VoteManagerInterface, "GetStakeSnapshot", epoch, stakerId) if err != nil { return nil, err } return returnedValues[0].Interface().(*big.Int), nil } -func (*UtilsStruct) GetTotalInfluenceRevealed(client *ethclient.Client, epoch uint32, medianIndex uint16) (*big.Int, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(VoteManagerInterface, "GetTotalInfluenceRevealed", client, epoch, medianIndex) +func (*UtilsStruct) GetTotalInfluenceRevealed(rpcParameters rpc.RPCParameters, epoch uint32, medianIndex uint16) (*big.Int, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, VoteManagerInterface, "GetTotalInfluenceRevealed", epoch, medianIndex) if err != nil { return nil, err } return returnedValues[0].Interface().(*big.Int), nil } -func (*UtilsStruct) GetEpochLastCommitted(client *ethclient.Client, stakerId uint32) (uint32, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(VoteManagerInterface, "GetEpochLastCommitted", client, stakerId) +func (*UtilsStruct) GetEpochLastCommitted(rpcParameters rpc.RPCParameters, stakerId uint32) (uint32, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, VoteManagerInterface, "GetEpochLastCommitted", stakerId) if err != nil { return 0, err } return returnedValues[0].Interface().(uint32), nil } -func (*UtilsStruct) GetEpochLastRevealed(client *ethclient.Client, stakerId uint32) (uint32, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(VoteManagerInterface, "GetEpochLastRevealed", client, stakerId) +func (*UtilsStruct) GetEpochLastRevealed(rpcParameters rpc.RPCParameters, stakerId uint32) (uint32, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, VoteManagerInterface, "GetEpochLastRevealed", stakerId) if err != nil { return 0, err } return returnedValues[0].Interface().(uint32), nil } -func (*UtilsStruct) ToAssign(client *ethclient.Client) (uint16, error) { - returnedValues, err := InvokeFunctionWithRetryAttempts(VoteManagerInterface, "ToAssign", client) +func (*UtilsStruct) ToAssign(rpcParameters rpc.RPCParameters) (uint16, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, VoteManagerInterface, "ToAssign") if err != nil { return 0, err } return returnedValues[0].Interface().(uint16), nil } + +func (*UtilsStruct) GetSaltFromBlockchain(rpcParameters rpc.RPCParameters) ([32]byte, error) { + returnedValues, err := InvokeFunctionWithRetryAttempts(rpcParameters, VoteManagerInterface, "GetSaltFromBlockchain") + if err != nil { + return [32]byte{}, err + } + return returnedValues[0].Interface().([32]byte), nil +} diff --git a/utils/vote_test.go b/utils/vote_test.go index df90c568b..fdc2f9318 100644 --- a/utils/vote_test.go +++ b/utils/vote_test.go @@ -16,7 +16,6 @@ import ( ) func TestGetCommitments(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts var address string @@ -74,11 +73,11 @@ func TestGetCommitments(t *testing.T) { utils := StartRazor(optionsPackageStruct) utilsMock.On("GetOptions").Return(callOpts) - utilsMock.On("GetStakerId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.stakerId, tt.args.stakerIdErr) + utilsMock.On("GetStakerId", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.stakerId, tt.args.stakerIdErr) voteManagerMock.On("GetCommitment", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.commitments, tt.args.commitmentErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetCommitment(client, address) + got, err := utils.GetCommitment(rpcParameters, address) if (err != nil) != tt.wantErr { t.Errorf("GetCommitment() error = %v, wantErr %v", err, tt.wantErr) return @@ -91,7 +90,6 @@ func TestGetCommitments(t *testing.T) { } func TestGetEpochLastCommitted(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts var stakerId uint32 @@ -139,7 +137,7 @@ func TestGetEpochLastCommitted(t *testing.T) { voteManagerMock.On("GetEpochLastCommitted", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.epochLastCommitted, tt.args.epochLastCommittedErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetEpochLastCommitted(client, stakerId) + got, err := utils.GetEpochLastCommitted(rpcParameters, stakerId) if (err != nil) != tt.wantErr { t.Errorf("GetEpochLastCommitted() error = %v, wantErr %v", err, tt.wantErr) return @@ -152,7 +150,6 @@ func TestGetEpochLastCommitted(t *testing.T) { } func TestGetEpochLastRevealed(t *testing.T) { - var client *ethclient.Client var stakerId uint32 type args struct { @@ -198,7 +195,7 @@ func TestGetEpochLastRevealed(t *testing.T) { voteManagerMock.On("GetEpochLastRevealed", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.epochLastRevealed, tt.args.epochLastRevealedErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetEpochLastRevealed(client, stakerId) + got, err := utils.GetEpochLastRevealed(rpcParameters, stakerId) if (err != nil) != tt.wantErr { t.Errorf("GetEpochLastRevealed() error = %v, wantErr %v", err, tt.wantErr) return @@ -211,7 +208,6 @@ func TestGetEpochLastRevealed(t *testing.T) { } func TestGetInfluenceSnapshot(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts var stakerId uint32 var epoch uint32 @@ -260,7 +256,7 @@ func TestGetInfluenceSnapshot(t *testing.T) { voteManagerMock.On("GetInfluenceSnapshot", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(tt.args.influenceSnapshot, tt.args.influenceErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetInfluenceSnapshot(client, stakerId, epoch) + got, err := utils.GetInfluenceSnapshot(rpcParameters, stakerId, epoch) if (err != nil) != tt.wantErr { t.Errorf("GetInfluenceSnapshot() error = %v, wantErr %v", err, tt.wantErr) return @@ -273,7 +269,6 @@ func TestGetInfluenceSnapshot(t *testing.T) { } func TestGetStakeSnapshot(t *testing.T) { - var client *ethclient.Client var callOpts bind.CallOpts var stakerId uint32 var epoch uint32 @@ -322,7 +317,7 @@ func TestGetStakeSnapshot(t *testing.T) { voteManagerMock.On("GetStakeSnapshot", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(tt.args.stakeSnapshot, tt.args.snapshotErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetStakeSnapshot(client, stakerId, epoch) + got, err := utils.GetStakeSnapshot(rpcParameters, stakerId, epoch) if (err != nil) != tt.wantErr { t.Errorf("GetStakeSnapshot() error = %v, wantErr %v", err, tt.wantErr) return @@ -336,7 +331,6 @@ func TestGetStakeSnapshot(t *testing.T) { func TestGetTotalInfluenceRevealed(t *testing.T) { var ( - client *ethclient.Client callOpts bind.CallOpts epoch uint32 medianIndex uint16 @@ -386,7 +380,7 @@ func TestGetTotalInfluenceRevealed(t *testing.T) { voteManagerMock.On("GetTotalInfluenceRevealed", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint16")).Return(tt.args.totalInfluenceRevealed, tt.args.influenceErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetTotalInfluenceRevealed(client, epoch, medianIndex) + got, err := utils.GetTotalInfluenceRevealed(rpcParameters, epoch, medianIndex) if (err != nil) != tt.wantErr { t.Errorf("GetTotalInfluenceRevealed() error = %v, wantErr %v", err, tt.wantErr) return @@ -400,7 +394,6 @@ func TestGetTotalInfluenceRevealed(t *testing.T) { func TestGetVoteValue(t *testing.T) { var ( - client *ethclient.Client callOpts bind.CallOpts medianIndex uint16 stakerId uint32 @@ -451,7 +444,7 @@ func TestGetVoteValue(t *testing.T) { voteManagerMock.On("GetVoteValue", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint16")).Return(tt.args.voteValue, tt.args.voteValueErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.GetVoteValue(client, epoch, stakerId, medianIndex) + got, err := utils.GetVoteValue(rpcParameters, epoch, stakerId, medianIndex) if (err != nil) != tt.wantErr { t.Errorf("GetVoteValue() error = %v, wantErr %v", err, tt.wantErr) return @@ -488,7 +481,6 @@ func TestGetVoteManagerWithOpts(t *testing.T) { } func TestToAssign(t *testing.T) { - var client *ethclient.Client type args struct { toAssign uint16 toAssignErr error @@ -530,7 +522,7 @@ func TestToAssign(t *testing.T) { voteManagerMock.On("ToAssign", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.toAssign, tt.args.toAssignErr) retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1)) - got, err := utils.ToAssign(client) + got, err := utils.ToAssign(rpcParameters) if (err != nil) != tt.wantErr { t.Errorf("ToAssign() error = %v, wantErr %v", err, tt.wantErr) return