From 1fb1365030443130179ab46e1fa935abde3bb3a5 Mon Sep 17 00:00:00 2001 From: chris erway Date: Wed, 5 Apr 2023 22:19:18 -0400 Subject: [PATCH] enable govet shadow linter and fix issues --- .golangci.yml | 10 ++ agreement/demux.go | 6 +- agreement/pseudonode.go | 12 +- cmd/algocfg/profileCommand.go | 8 +- cmd/catchpointdump/net.go | 4 +- cmd/goal/account.go | 10 +- cmd/goal/application.go | 138 +++++++++--------- cmd/goal/asset.go | 102 ++++++------- cmd/goal/interact.go | 12 +- cmd/goal/network.go | 6 +- cmd/goal/tealsign.go | 12 +- cmd/loadgenerator/main.go | 8 +- cmd/netgoal/network.go | 10 +- cmd/pingpong/runCmd.go | 30 ++-- crypto/stateproof/prover.go | 6 +- daemon/algod/api/server/v2/handlers.go | 32 ++-- daemon/algod/server.go | 14 +- data/account/participationRegistry.go | 20 +-- data/account/registeryDbOps.go | 16 +- data/transactions/logic/assembler.go | 12 +- data/transactions/logic/eval.go | 68 ++++----- data/transactions/logic/frames.go | 16 +- ledger/acctdeltas.go | 3 +- ledger/acctonline.go | 6 +- ledger/acctupdates.go | 38 ++--- ledger/apply/application.go | 18 +-- ledger/apply/asset.go | 12 +- ledger/catchpointtracker.go | 107 +++++++------- ledger/catchupaccessor.go | 46 +++--- ledger/eval/eval.go | 40 ++--- ledger/eval/prefetcher/prefetcher.go | 20 +-- .../trackerdb/sqlitedriver/accountsV2.go | 6 +- .../sqlitedriver/orderedAccountsIter.go | 12 +- ledger/store/trackerdb/sqlitedriver/schema.go | 70 ++++----- ledger/store/trackerdb/sqlitedriver/sql.go | 4 +- .../trackerdb/sqlitedriver/trackerdbV2.go | 6 +- netdeploy/networkTemplate.go | 6 +- network/wsNetwork.go | 12 +- shared/pingpong/accounts.go | 6 +- stateproof/builder.go | 6 +- tools/debug/dumpblocks/main.go | 2 +- util/execpool/stream.go | 8 +- 42 files changed, 497 insertions(+), 483 deletions(-) diff --git a/.golangci.yml b/.golangci.yml index ff7892d4f6..c2e9695aac 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -38,7 +38,12 @@ linters-settings: # We do this 121 times and never check the error. - (*github.com/spf13/cobra.Command).MarkFlagRequired govet: + check-shadowing: true settings: + shadow: + # explanation of strict vs non-strict: + # https://github.com/golang/tools/blob/v0.7.0/go/analysis/passes/shadow/shadow.go#L104-L122 + strict: false printf: # Comma-separated list of print function names to check (in addition to default, see `go tool vet help printf`). # Default: [] @@ -118,6 +123,11 @@ issues: # - revive - staticcheck - typecheck + # allow shadowing in test code + - path: _test\.go + linters: + - govet + text: "shadows declaration at line" # Ignore missing parallel tests in existing packages - path: ^agreement.*_test\.go linters: diff --git a/agreement/demux.go b/agreement/demux.go index 33584490f7..f31c4d075d 100644 --- a/agreement/demux.go +++ b/agreement/demux.go @@ -125,9 +125,9 @@ func (d *demux) tokenizeMessages(ctx context.Context, net Network, tag protocol. if err != nil { warnMsg := fmt.Sprintf("disconnecting from peer: error decoding message tagged %v: %v", tag, err) // check protocol version - cv, err := d.ledger.ConsensusVersion(d.ledger.NextRound()) - if err == nil { - if _, ok := config.Consensus[cv]; !ok { + cv, cvErr := d.ledger.ConsensusVersion(d.ledger.NextRound()) + if cvErr == nil { + if _, found := config.Consensus[cv]; !found { warnMsg = fmt.Sprintf("received proposal message was ignored. The node binary doesn't support the next network consensus (%v) and would no longer be able to process agreement messages", cv) } } diff --git a/agreement/pseudonode.go b/agreement/pseudonode.go index 3ebb681ca9..78f6674d7b 100644 --- a/agreement/pseudonode.go +++ b/agreement/pseudonode.go @@ -295,17 +295,17 @@ func (n asyncPseudonode) makeProposals(round basics.Round, period period, accoun votes := make([]unauthenticatedVote, 0, len(accounts)) proposals := make([]proposal, 0, len(accounts)) for _, acc := range accounts { - payload, proposal, err := proposalForBlock(acc.Account, acc.VRF, ve, period, n.ledger) - if err != nil { - n.log.Errorf("pseudonode.makeProposals: could not create proposal for block (address %v): %v", acc.Account, err) + payload, proposal, pErr := proposalForBlock(acc.Account, acc.VRF, ve, period, n.ledger) + if pErr != nil { + n.log.Errorf("pseudonode.makeProposals: could not create proposal for block (address %v): %v", acc.Account, pErr) continue } // attempt to make the vote rv := rawVote{Sender: acc.Account, Round: round, Period: period, Step: propose, Proposal: proposal} - uv, err := makeVote(rv, acc.VotingSigner(), acc.VRF, n.ledger) - if err != nil { - n.log.Warnf("pseudonode.makeProposals: could not create vote: %v", err) + uv, vErr := makeVote(rv, acc.VotingSigner(), acc.VRF, n.ledger) + if vErr != nil { + n.log.Warnf("pseudonode.makeProposals: could not create vote: %v", vErr) continue } diff --git a/cmd/algocfg/profileCommand.go b/cmd/algocfg/profileCommand.go index bbddfa26c7..61ba5fc695 100644 --- a/cmd/algocfg/profileCommand.go +++ b/cmd/algocfg/profileCommand.go @@ -142,13 +142,13 @@ var setProfileCmd = &cobra.Command{ reportErrorf("%v", err) } file := filepath.Join(dataDir, config.ConfigFilename) - if _, err := os.Stat(file); !forceUpdate && err == nil { + if _, statErr := os.Stat(file); !forceUpdate && statErr == nil { fmt.Printf("A config.json file already exists for this data directory. Would you like to overwrite it? (Y/n)") reader := bufio.NewReader(os.Stdin) - resp, err := reader.ReadString('\n') + resp, readErr := reader.ReadString('\n') resp = strings.TrimSpace(resp) - if err != nil { - reportErrorf("Failed to read response: %v", err) + if readErr != nil { + reportErrorf("Failed to read response: %v", readErr) } if strings.ToLower(resp) == "n" { reportInfof("Exiting without overwriting existing config.") diff --git a/cmd/catchpointdump/net.go b/cmd/catchpointdump/net.go index e0fdb7f890..77c28870fc 100644 --- a/cmd/catchpointdump/net.go +++ b/cmd/catchpointdump/net.go @@ -314,8 +314,8 @@ func loadAndDump(addr string, tarFile string, genesisInitState ledgercore.InitSt } defer func() { - if err := deleteLedgerFiles(!loadOnly); err != nil { - reportWarnf("Error deleting ledger files: %v", err) + if delErr := deleteLedgerFiles(!loadOnly); delErr != nil { + reportWarnf("Error deleting ledger files: %v", delErr) } }() defer l.Close() diff --git a/cmd/goal/account.go b/cmd/goal/account.go index c8becdb8fd..1ca85e5677 100644 --- a/cmd/goal/account.go +++ b/cmd/goal/account.go @@ -948,16 +948,16 @@ No --delete-input flag specified, exiting without installing key.`) reportErrorf(errorRequestFail, err) } // In an abundance of caution, check for ourselves that the key has been installed. - if err := client.VerifyParticipationKey(time.Minute, addResponse.PartId); err != nil { - err = fmt.Errorf("unable to verify key installation. Verify key installation with 'goal account partkeyinfo' and delete '%s', or retry the command. Error: %w", partKeyFile, err) - reportErrorf(errorRequestFail, err) + if vErr := client.VerifyParticipationKey(time.Minute, addResponse.PartId); vErr != nil { + vErr = fmt.Errorf("unable to verify key installation. Verify key installation with 'goal account partkeyinfo' and delete '%s', or retry the command. Error: %w", partKeyFile, vErr) + reportErrorf(errorRequestFail, vErr) } reportInfof("Participation key installed successfully, Participation ID: %s\n", addResponse.PartId) // Delete partKeyFile - if nil != os.Remove(partKeyFile) { - reportErrorf("An error occurred while removing the partkey file, please delete it manually: %s", err) + if osErr := os.Remove(partKeyFile); osErr != nil { + reportErrorf("An error occurred while removing the partkey file, please delete it manually: %s", osErr) } }, } diff --git a/cmd/goal/application.go b/cmd/goal/application.go index 0c5e9e0cbf..b3ac15e41a 100644 --- a/cmd/goal/application.go +++ b/cmd/goal/application.go @@ -484,14 +484,14 @@ var createAppCmd = &cobra.Command{ if outFilename == "" { // Broadcast wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } reportInfof("Attempting to create app (approval size %d, hash %v; clear size %d, hash %v)", len(approvalProg), crypto.HashObj(logic.Program(approvalProg)), len(clearProg), crypto.HashObj(logic.Program(clearProg))) @@ -559,23 +559,23 @@ var updateAppCmd = &cobra.Command{ // Broadcast or write transaction to file if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } reportInfof("Attempting to update app (approval size %d, hash %v; clear size %d, hash %v)", len(approvalProg), crypto.HashObj(logic.Program(approvalProg)), len(clearProg), crypto.HashObj(logic.Program(clearProg))) reportInfof("Issued transaction from account %s, txid %s (fee %d)", tx.Sender, txid, tx.Fee.Raw) if !noWaitAfterSend { - _, err = waitForCommit(client, txid, lv) - if err != nil { - reportErrorf(err.Error()) + _, err2 = waitForCommit(client, txid, lv) + if err2 != nil { + reportErrorf(err2.Error()) } } } else { @@ -629,23 +629,23 @@ var optInAppCmd = &cobra.Command{ // Broadcast or write transaction to file if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } // Report tx details to user reportInfof("Issued transaction from account %s, txid %s (fee %d)", tx.Sender, txid, tx.Fee.Raw) if !noWaitAfterSend { - _, err = waitForCommit(client, txid, lv) - if err != nil { - reportErrorf(err.Error()) + _, err2 = waitForCommit(client, txid, lv) + if err2 != nil { + reportErrorf(err2.Error()) } } } else { @@ -699,23 +699,23 @@ var closeOutAppCmd = &cobra.Command{ // Broadcast or write transaction to file if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } // Report tx details to user reportInfof("Issued transaction from account %s, txid %s (fee %d)", tx.Sender, txid, tx.Fee.Raw) if !noWaitAfterSend { - _, err = waitForCommit(client, txid, lv) - if err != nil { - reportErrorf(err.Error()) + _, err2 = waitForCommit(client, txid, lv) + if err2 != nil { + reportErrorf(err2.Error()) } } } else { @@ -769,23 +769,23 @@ var clearAppCmd = &cobra.Command{ // Broadcast or write transaction to file if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } // Report tx details to user reportInfof("Issued transaction from account %s, txid %s (fee %d)", tx.Sender, txid, tx.Fee.Raw) if !noWaitAfterSend { - _, err = waitForCommit(client, txid, lv) - if err != nil { - reportErrorf(err.Error()) + _, err2 = waitForCommit(client, txid, lv) + if err2 != nil { + reportErrorf(err2.Error()) } } } else { @@ -839,23 +839,23 @@ var callAppCmd = &cobra.Command{ // Broadcast or write transaction to file if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } // Report tx details to user reportInfof("Issued transaction from account %s, txid %s (fee %d)", tx.Sender, txid, tx.Fee.Raw) if !noWaitAfterSend { - _, err = waitForCommit(client, txid, lv) - if err != nil { - reportErrorf(err.Error()) + _, err2 = waitForCommit(client, txid, lv) + if err2 != nil { + reportErrorf(err2.Error()) } } } else { @@ -909,23 +909,23 @@ var deleteAppCmd = &cobra.Command{ // Broadcast or write transaction to file if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } // Report tx details to user reportInfof("Issued transaction from account %s, txid %s (fee %d)", tx.Sender, txid, tx.Fee.Raw) if !noWaitAfterSend { - _, err = waitForCommit(client, txid, lv) - if err != nil { - reportErrorf(err.Error()) + _, err2 = waitForCommit(client, txid, lv) + if err2 != nil { + reportErrorf(err2.Error()) } } } else { @@ -1314,9 +1314,9 @@ var methodAppCmd = &cobra.Command{ var retType *abi.Type if retTypeStr != abi.VoidReturnType { - theRetType, err := abi.TypeOf(retTypeStr) - if err != nil { - reportErrorf("cannot cast %s to abi type: %v", retTypeStr, err) + theRetType, typeErr := abi.TypeOf(retTypeStr) + if typeErr != nil { + reportErrorf("cannot cast %s to abi type: %v", retTypeStr, typeErr) } retType = &theRetType } @@ -1405,9 +1405,9 @@ var methodAppCmd = &cobra.Command{ txnGroup = append(txnGroup, appCallTxn) if len(txnGroup) > 1 { // Only if transaction arguments are present, assign group ID - groupID, err := client.GroupID(txnGroup) - if err != nil { - reportErrorf("Cannot assign transaction group ID: %s", err) + groupID, gidErr := client.GroupID(txnGroup) + if gidErr != nil { + reportErrorf("Cannot assign transaction group ID: %s", gidErr) } for i := range txnGroup { txnGroup[i].Group = groupID @@ -1432,9 +1432,9 @@ var methodAppCmd = &cobra.Command{ continue } - signedTxn, err := createSignedTransaction(client, shouldSign, dataDir, walletName, unsignedTxn, txnFromArgs.AuthAddr) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, signErr := createSignedTransaction(client, shouldSign, dataDir, walletName, unsignedTxn, txnFromArgs.AuthAddr) + if signErr != nil { + reportErrorf(errorSigningTX, signErr) } signedTxnGroup = append(signedTxnGroup, signedTxn) diff --git a/cmd/goal/asset.go b/cmd/goal/asset.go index f882f85c0d..64c2d4c56c 100644 --- a/cmd/goal/asset.go +++ b/cmd/goal/asset.go @@ -307,14 +307,14 @@ var createAssetCmd = &cobra.Command{ if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } // Report tx details to user @@ -386,23 +386,23 @@ var destroyAssetCmd = &cobra.Command{ if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } // Report tx details to user reportInfof("Issued transaction from account %s, txid %s (fee %d)", tx.Sender, txid, tx.Fee.Raw) if !noWaitAfterSend { - _, err = waitForCommit(client, txid, lastValid) - if err != nil { - reportErrorf(err.Error()) + _, err2 = waitForCommit(client, txid, lastValid) + if err2 != nil { + reportErrorf(err2.Error()) } } } else { @@ -479,23 +479,23 @@ var configAssetCmd = &cobra.Command{ if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } // Report tx details to user reportInfof("Issued transaction from account %s, txid %s (fee %d)", tx.Sender, txid, tx.Fee.Raw) if !noWaitAfterSend { - _, err = waitForCommit(client, txid, lastValid) - if err != nil { - reportErrorf(err.Error()) + _, err2 = waitForCommit(client, txid, lastValid) + if err2 != nil { + reportErrorf(err2.Error()) } } } else { @@ -566,23 +566,23 @@ var sendAssetCmd = &cobra.Command{ if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } // Report tx details to user reportInfof("Issued transaction from account %s, txid %s (fee %d)", tx.Sender, txid, tx.Fee.Raw) if !noWaitAfterSend { - _, err = waitForCommit(client, txid, lastValid) - if err != nil { - reportErrorf(err.Error()) + _, err2 = waitForCommit(client, txid, lastValid) + if err2 != nil { + reportErrorf(err2.Error()) } } } else { @@ -635,23 +635,23 @@ var freezeAssetCmd = &cobra.Command{ if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } // Report tx details to user reportInfof("Issued transaction from account %s, txid %s (fee %d)", tx.Sender, txid, tx.Fee.Raw) if !noWaitAfterSend { - _, err = waitForCommit(client, txid, lastValid) - if err != nil { - reportErrorf(err.Error()) + _, err2 = waitForCommit(client, txid, lastValid) + if err2 != nil { + reportErrorf(err2.Error()) } } } else { @@ -724,23 +724,23 @@ var optinAssetCmd = &cobra.Command{ if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } // Report tx details to user reportInfof("Issued transaction from account %s, txid %s (fee %d)", tx.Sender, txid, tx.Fee.Raw) if !noWaitAfterSend { - _, err = waitForCommit(client, txid, lastValid) - if err != nil { - reportErrorf(err.Error()) + _, err2 = waitForCommit(client, txid, lastValid) + if err2 != nil { + reportErrorf(err2.Error()) } } } else { diff --git a/cmd/goal/interact.go b/cmd/goal/interact.go index fcdcc3953c..825d74388f 100644 --- a/cmd/goal/interact.go +++ b/cmd/goal/interact.go @@ -614,14 +614,14 @@ var appExecuteCmd = &cobra.Command{ if outFilename == "" { wh, pw := ensureWalletHandleMaybePassword(dataDir, walletName, true) - signedTxn, err := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) - if err != nil { - reportErrorf(errorSigningTX, err) + signedTxn, err2 := client.SignTransactionWithWalletAndSigner(wh, pw, signerAddress, tx) + if err2 != nil { + reportErrorf(errorSigningTX, err2) } - txid, err := client.BroadcastTransaction(signedTxn) - if err != nil { - reportErrorf(errorBroadcastingTX, err) + txid, err2 := client.BroadcastTransaction(signedTxn) + if err2 != nil { + reportErrorf(errorBroadcastingTX, err2) } if appIdx == 0 { diff --git a/cmd/goal/network.go b/cmd/goal/network.go index ddad6f99d1..5c32b68e36 100644 --- a/cmd/goal/network.go +++ b/cmd/goal/network.go @@ -98,9 +98,9 @@ var networkCreateCmd = &cobra.Command{ if err != nil { panic(err) } - file, err := os.Open(networkTemplateFile) - if err != nil { - reportErrorf(errorCreateNetwork, err) + file, osErr := os.Open(networkTemplateFile) + if osErr != nil { + reportErrorf(errorCreateNetwork, osErr) } defer file.Close() diff --git a/cmd/goal/tealsign.go b/cmd/goal/tealsign.go index 33af6ca011..9d9f144da6 100644 --- a/cmd/goal/tealsign.go +++ b/cmd/goal/tealsign.go @@ -123,14 +123,14 @@ The base64 encoding of the signature will always be printed to stdout. Optionall if lsigTxnFilename != "" { // If passed a SignedTxn with a logic sig, compute // the hash of the program within the logic sig - stxnBytes, err := os.ReadFile(lsigTxnFilename) - if err != nil { - reportErrorf(fileReadError, lsigTxnFilename, err) + stxnBytes, err2 := os.ReadFile(lsigTxnFilename) + if err2 != nil { + reportErrorf(fileReadError, lsigTxnFilename, err2) } - err = protocol.Decode(stxnBytes, &stxn) - if err != nil { - reportErrorf(txDecodeError, lsigTxnFilename, err) + err2 = protocol.Decode(stxnBytes, &stxn) + if err2 != nil { + reportErrorf(txDecodeError, lsigTxnFilename, err2) } // Ensure signed transaction has a logic sig with a diff --git a/cmd/loadgenerator/main.go b/cmd/loadgenerator/main.go index 6ef8cd2383..4bca5510d6 100644 --- a/cmd/loadgenerator/main.go +++ b/cmd/loadgenerator/main.go @@ -106,11 +106,11 @@ func main() { if (cfg.ClientURL == nil || cfg.ClientURL.String() == "") || cfg.APIToken == "" { if algodDir != "" { path := filepath.Join(algodDir, "algod.net") - net, err := os.ReadFile(path) - maybefail(err, "%s: %v\n", path, err) + net, osErr := os.ReadFile(path) + maybefail(err, "%s: %v\n", path, osErr) path = filepath.Join(algodDir, "algod.token") - token, err := os.ReadFile(path) - maybefail(err, "%s: %v\n", path, err) + token, osErr := os.ReadFile(path) + maybefail(err, "%s: %v\n", path, osErr) cfg.ClientURL, err = url.Parse(fmt.Sprintf("http://%s", string(strings.TrimSpace(string(net))))) maybefail(err, "bad net url %v\n", err) cfg.APIToken = string(token) diff --git a/cmd/netgoal/network.go b/cmd/netgoal/network.go index f0efdc2cd6..7dfee6cbab 100644 --- a/cmd/netgoal/network.go +++ b/cmd/netgoal/network.go @@ -80,13 +80,13 @@ var networkBuildCmd = &cobra.Command{ func runBuildNetwork() (err error) { if cpuprofilePath != "" { - f, err := os.Create(cpuprofilePath) - if err != nil { - log.Fatalf("%s: could not create CPU profile, %v", cpuprofilePath, err) + f, osErr := os.Create(cpuprofilePath) + if osErr != nil { + log.Fatalf("%s: could not create CPU profile, %v", cpuprofilePath, osErr) } defer f.Close() // error handling omitted for example - if err := pprof.StartCPUProfile(f); err != nil { - log.Fatalf("%s: could not start CPU profile, %v", cpuprofilePath, err) + if ppErr := pprof.StartCPUProfile(f); ppErr != nil { + log.Fatalf("%s: could not start CPU profile, %v", cpuprofilePath, ppErr) } defer pprof.StopCPUProfile() } diff --git a/cmd/pingpong/runCmd.go b/cmd/pingpong/runCmd.go index 7813d4f313..78ff613009 100644 --- a/cmd/pingpong/runCmd.go +++ b/cmd/pingpong/runCmd.go @@ -153,14 +153,14 @@ var runCmd = &cobra.Command{ reportErrorf("Cannot make temp dir: %v\n", err) } if cpuprofile != "" { - proff, err := os.Create(cpuprofile) - if err != nil { - reportErrorf("%s: %v\n", cpuprofile, err) + proff, profErr := os.Create(cpuprofile) + if profErr != nil { + reportErrorf("%s: %v\n", cpuprofile, profErr) } defer proff.Close() - err = pprof.StartCPUProfile(proff) - if err != nil { - reportErrorf("%s: StartCPUProfile %v\n", cpuprofile, err) + profErr = pprof.StartCPUProfile(proff) + if profErr != nil { + reportErrorf("%s: StartCPUProfile %v\n", cpuprofile, profErr) } defer pprof.StopCPUProfile() } @@ -172,18 +172,18 @@ var runCmd = &cobra.Command{ } if pidFile != "" { - pidf, err := os.Create(pidFile) - if err != nil { - reportErrorf("%s: %v\n", pidFile, err) + pidf, pidErr := os.Create(pidFile) + if pidErr != nil { + reportErrorf("%s: %v\n", pidFile, pidErr) } defer os.Remove(pidFile) - _, err = fmt.Fprintf(pidf, "%d", os.Getpid()) - if err != nil { - reportErrorf("%s: %v\n", pidFile, err) + _, pidErr = fmt.Fprintf(pidf, "%d", os.Getpid()) + if pidErr != nil { + reportErrorf("%s: %v\n", pidFile, pidErr) } - err = pidf.Close() - if err != nil { - reportErrorf("%s: %v\n", pidFile, err) + pidErr = pidf.Close() + if pidErr != nil { + reportErrorf("%s: %v\n", pidFile, pidErr) } } diff --git a/crypto/stateproof/prover.go b/crypto/stateproof/prover.go index 64484ce35c..f3a8a43bca 100644 --- a/crypto/stateproof/prover.go +++ b/crypto/stateproof/prover.go @@ -228,9 +228,9 @@ func (b *Prover) CreateProof() (*StateProof, error) { revealsSequence := make([]uint64, nr) for j := uint64(0); j < nr; j++ { coin := coinHash.getNextCoin() - pos, err := b.coinIndex(coin) - if err != nil { - return nil, err + pos, idxErr := b.coinIndex(coin) + if idxErr != nil { + return nil, idxErr } if pos >= uint64(len(b.Participants)) { diff --git a/daemon/algod/api/server/v2/handlers.go b/daemon/algod/api/server/v2/handlers.go index 8e31f89902..123907e621 100644 --- a/daemon/algod/api/server/v2/handlers.go +++ b/daemon/algod/api/server/v2/handlers.go @@ -243,8 +243,8 @@ func (v2 *Handlers) AddParticipationKey(ctx echo.Context) error { partKeyBinary := buf.Bytes() if len(partKeyBinary) == 0 { - err := fmt.Errorf(errRESTPayloadZeroLength) - return badRequest(ctx, err, err.Error(), v2.Log) + lenErr := fmt.Errorf(errRESTPayloadZeroLength) + return badRequest(ctx, lenErr, lenErr.Error(), v2.Log) } partID, err := v2.Node.InstallParticipationKey(partKeyBinary) @@ -368,9 +368,9 @@ func (v2 *Handlers) AccountInformation(ctx echo.Context, address string, params // count total # of resources, if max limit is set if maxResults := v2.Node.Config().MaxAPIResourcesPerAccount; maxResults != 0 { - record, _, _, err := myLedger.LookupAccount(myLedger.Latest(), addr) - if err != nil { - return internalError(ctx, err, errFailedLookingUpLedger, v2.Log) + record, _, _, lookupErr := myLedger.LookupAccount(myLedger.Latest(), addr) + if lookupErr != nil { + return internalError(ctx, lookupErr, errFailedLookingUpLedger, v2.Log) } totalResults := record.TotalAssets + record.TotalAssetParams + record.TotalAppLocalStates + record.TotalAppParams if totalResults > maxResults { @@ -426,9 +426,9 @@ func (v2 *Handlers) basicAccountInformation(ctx echo.Context, addr basics.Addres } if handle == protocol.CodecHandle { - data, err := encode(handle, record) - if err != nil { - return internalError(ctx, err, errFailedToEncodeResponse, v2.Log) + data, encErr := encode(handle, record) + if encErr != nil { + return internalError(ctx, encErr, errFailedToEncodeResponse, v2.Log) } return ctx.Blob(http.StatusOK, contentType, data) } @@ -607,13 +607,13 @@ func (v2 *Handlers) GetBlock(ctx echo.Context, round uint64, params model.GetBlo // msgpack format uses 'RawBlockBytes' and attaches a custom header. if handle == protocol.CodecHandle { - blockbytes, err := rpcs.RawBlockBytes(v2.Node.LedgerForAPI(), basics.Round(round)) - if err != nil { - switch err.(type) { + blockbytes, blockErr := rpcs.RawBlockBytes(v2.Node.LedgerForAPI(), basics.Round(round)) + if blockErr != nil { + switch blockErr.(type) { case ledgercore.ErrNoEntry: - return notFound(ctx, err, errFailedLookingUpLedger, v2.Log) + return notFound(ctx, blockErr, errFailedLookingUpLedger, v2.Log) default: - return internalError(ctx, err, err.Error(), v2.Log) + return internalError(ctx, blockErr, blockErr.Error(), v2.Log) } } @@ -728,9 +728,9 @@ func (v2 *Handlers) GetTransactionProof(ctx echo.Context, round uint64, txid str return badRequest(ctx, err, "unsupported hash type", v2.Log) } - proof, err := tree.ProveSingleLeaf(uint64(idx)) - if err != nil { - return internalError(ctx, err, "generating proof", v2.Log) + proof, proofErr := tree.ProveSingleLeaf(uint64(idx)) + if proofErr != nil { + return internalError(ctx, proofErr, "generating proof", v2.Log) } response := model.TransactionProofResponse{ diff --git a/daemon/algod/server.go b/daemon/algod/server.go index 2283ef8e0d..b764748997 100644 --- a/daemon/algod/server.go +++ b/daemon/algod/server.go @@ -131,13 +131,13 @@ func (s *Server) Initialize(cfg config.Local, phonebookAddresses []string, genes } if cfg.IsGossipServer() { var ot basics.OverflowTracker - fdRequired := ot.Add(fdRequired, uint64(cfg.IncomingConnectionsLimit)) + fdRequired = ot.Add(fdRequired, uint64(cfg.IncomingConnectionsLimit)) if ot.Overflowed { return errors.New("Initialize() overflowed when adding up IncomingConnectionsLimit to the existing RLIMIT_NOFILE value; decrease RestConnectionsHardLimit or IncomingConnectionsLimit") } - _, hard, err := util.GetFdLimits() - if err != nil { - s.log.Errorf("Failed to get RLIMIT_NOFILE values: %s", err.Error()) + _, hard, fdErr := util.GetFdLimits() + if fdErr != nil { + s.log.Errorf("Failed to get RLIMIT_NOFILE values: %s", fdErr.Error()) } else { maxFDs := fdRequired if fdRequired > hard { @@ -156,10 +156,10 @@ func (s *Server) Initialize(cfg config.Local, phonebookAddresses []string, genes } } } - err = util.SetFdSoftLimit(maxFDs) - if err != nil { + fdErr = util.SetFdSoftLimit(maxFDs) + if fdErr != nil { // do not fail but log the error - s.log.Errorf("Failed to set a new RLIMIT_NOFILE value to %d (max %d): %s", fdRequired, hard, err.Error()) + s.log.Errorf("Failed to set a new RLIMIT_NOFILE value to %d (max %d): %s", fdRequired, hard, fdErr.Error()) } } } diff --git a/data/account/participationRegistry.go b/data/account/participationRegistry.go index bc9d0b301c..120b71431f 100644 --- a/data/account/participationRegistry.go +++ b/data/account/participationRegistry.go @@ -780,18 +780,18 @@ func (db *participationDB) GetStateProofSecretsForRound(id ParticipationID, roun var rawStateProofKey []byte err = db.store.Rdb.Atomic(func(ctx context.Context, tx *sql.Tx) error { // fetch secret key - keyFirstValidRound, err := partRecord.StateProof.FirstRoundInKeyLifetime(uint64(round)) - if err != nil { - return err + keyFirstValidRound, err2 := partRecord.StateProof.FirstRoundInKeyLifetime(uint64(round)) + if err2 != nil { + return err2 } row := tx.QueryRow(selectStateProofKey, keyFirstValidRound, id[:]) - err = row.Scan(&rawStateProofKey) - if err == sql.ErrNoRows { + err2 = row.Scan(&rawStateProofKey) + if err2 == sql.ErrNoRows { return ErrSecretNotFound } - if err != nil { - return fmt.Errorf("error while querying secrets: %w", err) + if err2 != nil { + return fmt.Errorf("error while querying secrets: %w", err2) } return nil @@ -814,9 +814,9 @@ func (db *participationDB) GetStateProofSecretsForRound(id ParticipationID, roun err = db.store.Rdb.Atomic(func(ctx context.Context, tx *sql.Tx) error { // fetch stateproof public data row := tx.QueryRow(selectStateProofData, id[:]) - err := row.Scan(&rawSignerContext) - if err != nil { - return fmt.Errorf("error while querying stateproof data: %w", err) + err2 := row.Scan(&rawSignerContext) + if err2 != nil { + return fmt.Errorf("error while querying stateproof data: %w", err2) } return nil }) diff --git a/data/account/registeryDbOps.go b/data/account/registeryDbOps.go index e6722e5eb5..ad5174c1c8 100644 --- a/data/account/registeryDbOps.go +++ b/data/account/registeryDbOps.go @@ -150,7 +150,7 @@ func (i *insertOp) apply(db *participationDB) (err error) { } err = db.store.Wdb.Atomic(func(ctx context.Context, tx *sql.Tx) error { - result, err := tx.Exec( + result, err2 := tx.Exec( insertKeysetQuery, i.id[:], i.record.Parent[:], @@ -159,17 +159,17 @@ func (i *insertOp) apply(db *participationDB) (err error) { i.record.KeyDilution, rawVRF, rawStateProofContext) - if err = verifyExecWithOneRowEffected(err, result, "insert keyset"); err != nil { - return err + if err2 = verifyExecWithOneRowEffected(err2, result, "insert keyset"); err2 != nil { + return err2 } - pk, err := result.LastInsertId() - if err != nil { - return fmt.Errorf("unable to get pk from keyset: %w", err) + pk, err2 := result.LastInsertId() + if err2 != nil { + return fmt.Errorf("unable to get pk from keyset: %w", err2) } // Create Rolling entry - result, err = tx.Exec(insertRollingQuery, pk, rawVoting) - return verifyExecWithOneRowEffected(err, result, "insert rolling") + result, err2 = tx.Exec(insertRollingQuery, pk, rawVoting) + return verifyExecWithOneRowEffected(err2, result, "insert rolling") }) return err } diff --git a/data/transactions/logic/assembler.go b/data/transactions/logic/assembler.go index 9e726a977e..724ba48982 100644 --- a/data/transactions/logic/assembler.go +++ b/data/transactions/logic/assembler.go @@ -1545,15 +1545,15 @@ func pseudoImmediatesError(ops *OpStream, name string, specs map[int]OpSpec) { func getSpec(ops *OpStream, name string, args []string) (OpSpec, string, bool) { pseudoSpecs, ok := ops.versionedPseudoOps[name] if ok { - pseudo, ok := pseudoSpecs[len(args)] - if !ok { + pseudo, ok2 := pseudoSpecs[len(args)] + if !ok2 { // Could be that pseudoOp wants to handle immediates itself so check -1 key - pseudo, ok = pseudoSpecs[anyImmediates] - if !ok { + pseudo, ok2 = pseudoSpecs[anyImmediates] + if !ok2 { // Number of immediates supplied did not match any of the pseudoOps of the given name, so we try to construct a mock spec that can be used to track types pseudoImmediatesError(ops, name, pseudoSpecs) - proto, version, ok := mergeProtos(pseudoSpecs) - if !ok { + proto, version, ok3 := mergeProtos(pseudoSpecs) + if !ok3 { return OpSpec{}, "", false } pseudo = OpSpec{Name: name, Proto: proto, Version: version, OpDetails: OpDetails{asm: func(*OpStream, *OpSpec, []string) error { return nil }}} diff --git a/data/transactions/logic/eval.go b/data/transactions/logic/eval.go index 3de0f101d6..8d50624325 100644 --- a/data/transactions/logic/eval.go +++ b/data/transactions/logic/eval.go @@ -2383,26 +2383,26 @@ func opRetSub(cx *EvalContext) error { if top < 0 { return errors.New("retsub with empty callstack") } - frame := cx.callstack[top] - if frame.clear { // A `proto` was issued in the subroutine, so retsub cleans up. - expect := frame.height + frame.returns + topFrame := cx.callstack[top] + if topFrame.clear { // A `proto` was issued in the subroutine, so retsub cleans up. + expect := topFrame.height + topFrame.returns if len(cx.stack) < expect { // Check general error case first, only diffentiate when error is assured switch { - case len(cx.stack) < frame.height: + case len(cx.stack) < topFrame.height: return fmt.Errorf("retsub executed with stack below frame. Did you pop args?") - case len(cx.stack) == frame.height: - return fmt.Errorf("retsub executed with no return values on stack. proto declared %d", frame.returns) + case len(cx.stack) == topFrame.height: + return fmt.Errorf("retsub executed with no return values on stack. proto declared %d", topFrame.returns) default: return fmt.Errorf("retsub executed with %d return values on stack. proto declared %d", - len(cx.stack)-frame.height, frame.returns) + len(cx.stack)-topFrame.height, topFrame.returns) } } - argstart := frame.height - frame.args - copy(cx.stack[argstart:], cx.stack[frame.height:expect]) - cx.stack = cx.stack[:argstart+frame.returns] + argstart := topFrame.height - topFrame.args + copy(cx.stack[argstart:], cx.stack[topFrame.height:expect]) + cx.stack = cx.stack[:argstart+topFrame.returns] } cx.callstack = cx.callstack[:top] - cx.nextpc = frame.retpc + cx.nextpc = topFrame.retpc return nil } @@ -4065,8 +4065,8 @@ func (cx *EvalContext) mutableAccountReference(account stackValue) (basics.Addre // There was no error, but accountReference has signaled that accountIdx // is not for mutable ops (because it can't encode it in EvalDelta) // This also tells us that account.address() will work. - addr, _ := account.address() - err = fmt.Errorf("invalid Account reference for mutation %s", addr) + acctAddr, _ := account.address() + err = fmt.Errorf("invalid Account reference for mutation %s", acctAddr) } return addr, accountIdx, err } @@ -4347,9 +4347,9 @@ func opAppLocalDel(cx *EvalContext) error { // if deleting a non-existent value, don't record in EvalDelta, matching // ledger behavior with previous BuildEvalDelta mechanism - if _, ok, err := cx.Ledger.GetLocal(addr, cx.appID, key, accountIdx); ok { - if err != nil { - return err + if _, ok, getErr := cx.Ledger.GetLocal(addr, cx.appID, key, accountIdx); ok { + if getErr != nil { + return getErr } if _, ok := cx.txn.EvalDelta.LocalDeltas[accountIdx]; !ok { cx.txn.EvalDelta.LocalDeltas[accountIdx] = basics.StateDelta{} @@ -5108,16 +5108,16 @@ func opItxnSubmit(cx *EvalContext) (err error) { // transaction pool. Namely that any transaction that makes it // to Perform (which is equivalent to eval.applyTransaction) // is authorized, and WellFormed. - err := authorizedSender(cx, cx.subtxns[itx].Txn.Sender) - if err != nil { - return err + txnErr := authorizedSender(cx, cx.subtxns[itx].Txn.Sender) + if txnErr != nil { + return txnErr } // Recall that WellFormed does not care about individual // transaction fees because of fee pooling. Checked above. - err = cx.subtxns[itx].Txn.WellFormed(*cx.Specials, *cx.Proto) - if err != nil { - return err + txnErr = cx.subtxns[itx].Txn.WellFormed(*cx.Specials, *cx.Proto) + if txnErr != nil { + return txnErr } // Disallow reentrancy, limit inner app call depth, and do version checks @@ -5139,9 +5139,9 @@ func opItxnSubmit(cx *EvalContext) (err error) { // Set program by txn, approval, or clear state program := cx.subtxns[itx].Txn.ApprovalProgram if cx.subtxns[itx].Txn.ApplicationID != 0 { - app, _, err := cx.Ledger.AppParams(cx.subtxns[itx].Txn.ApplicationID) - if err != nil { - return err + app, _, paramsErr := cx.Ledger.AppParams(cx.subtxns[itx].Txn.ApplicationID) + if paramsErr != nil { + return paramsErr } program = app.ApprovalProgram if cx.subtxns[itx].Txn.OnCompletion == transactions.ClearStateOC { @@ -5150,9 +5150,9 @@ func opItxnSubmit(cx *EvalContext) (err error) { } // Can't call old versions in inner apps. - v, _, err := transactions.ProgramVersion(program) - if err != nil { - return err + v, _, verErr := transactions.ProgramVersion(program) + if verErr != nil { + return verErr } if v < cx.Proto.MinInnerApplVersion { return fmt.Errorf("inner app call with version v%d < v%d", @@ -5165,15 +5165,15 @@ func opItxnSubmit(cx *EvalContext) (err error) { if cx.subtxns[itx].Txn.OnCompletion == transactions.OptInOC { csp := cx.subtxns[itx].Txn.ClearStateProgram if cx.subtxns[itx].Txn.ApplicationID != 0 { - app, _, err := cx.Ledger.AppParams(cx.subtxns[itx].Txn.ApplicationID) - if err != nil { - return err + app, _, paramsErr := cx.Ledger.AppParams(cx.subtxns[itx].Txn.ApplicationID) + if paramsErr != nil { + return paramsErr } csp = app.ClearStateProgram } - csv, _, err := transactions.ProgramVersion(csp) - if err != nil { - return err + csv, _, verErr := transactions.ProgramVersion(csp) + if verErr != nil { + return verErr } if csv < cx.Proto.MinInnerApplVersion { return fmt.Errorf("inner app call opt-in with CSP v%d < v%d", diff --git a/data/transactions/logic/frames.go b/data/transactions/logic/frames.go index 4eda0e9330..b8abc60570 100644 --- a/data/transactions/logic/frames.go +++ b/data/transactions/logic/frames.go @@ -45,12 +45,12 @@ func opFrameDig(cx *EvalContext) error { return errors.New("frame_dig with empty callstack") } - frame := cx.callstack[top] + topFrame := cx.callstack[top] // If proto was used, don't allow `frame_dig` to go below specified args - if frame.clear && -int(i) > frame.args { - return fmt.Errorf("frame_dig %d in sub with %d args", i, frame.args) + if topFrame.clear && -int(i) > topFrame.args { + return fmt.Errorf("frame_dig %d in sub with %d args", i, topFrame.args) } - idx := frame.height + int(i) + idx := topFrame.height + int(i) if idx >= len(cx.stack) { return errors.New("frame_dig above stack") } @@ -70,12 +70,12 @@ func opFrameBury(cx *EvalContext) error { return errors.New("frame_bury with empty callstack") } - frame := cx.callstack[top] + topFrame := cx.callstack[top] // If proto was used, don't allow `frame_bury` to go below specified args - if frame.clear && -int(i) > frame.args { - return fmt.Errorf("frame_bury %d in sub with %d args", i, frame.args) + if topFrame.clear && -int(i) > topFrame.args { + return fmt.Errorf("frame_bury %d in sub with %d args", i, topFrame.args) } - idx := frame.height + int(i) + idx := topFrame.height + int(i) if idx >= last { return errors.New("frame_bury above stack") } diff --git a/ledger/acctdeltas.go b/ledger/acctdeltas.go index fcc937e01f..9c95e3c426 100644 --- a/ledger/acctdeltas.go +++ b/ledger/acctdeltas.go @@ -760,7 +760,8 @@ func accountsNewRoundImpl( } else { // create a new entry. normBalance := data.newAcct.NormalizedOnlineBalance(proto) - ref, err := writer.InsertAccount(data.address, normBalance, data.newAcct) + var ref trackerdb.AccountRef + ref, err = writer.InsertAccount(data.address, normBalance, data.newAcct) if err == nil { updatedAccounts[updatedAccountIdx].Ref = ref updatedAccounts[updatedAccountIdx].AccountData = data.newAcct diff --git a/ledger/acctonline.go b/ledger/acctonline.go index 66aff375a5..b9b097cb92 100644 --- a/ledger/acctonline.go +++ b/ledger/acctonline.go @@ -154,9 +154,9 @@ func (ao *onlineAccounts) initializeFromDisk(l ledgerForTracker, lastBalancesRou ao.log = l.trackerLog() err = ao.dbs.Snapshot(func(ctx context.Context, tx trackerdb.SnapshotScope) error { - ar, err := tx.MakeAccountsReader() - if err != nil { - return err + ar, makeErr := tx.MakeAccountsReader() + if makeErr != nil { + return makeErr } var err0 error diff --git a/ledger/acctupdates.go b/ledger/acctupdates.go index 4e934bbf55..6fb53bad90 100644 --- a/ledger/acctupdates.go +++ b/ledger/acctupdates.go @@ -929,17 +929,17 @@ func (au *accountUpdates) latestTotalsImpl() (basics.Round, ledgercore.AccountTo // initializeFromDisk performs the atomic operation of loading the accounts data information from disk // and preparing the accountUpdates for operation. -func (au *accountUpdates) initializeFromDisk(l ledgerForTracker, lastBalancesRound basics.Round) (err error) { +func (au *accountUpdates) initializeFromDisk(l ledgerForTracker, lastBalancesRound basics.Round) error { au.dbs = l.trackerDB() au.log = l.trackerLog() au.ledger = l start := time.Now() ledgerAccountsinitCount.Inc(nil) - err = au.dbs.Snapshot(func(ctx context.Context, tx trackerdb.SnapshotScope) error { - ar, err := tx.MakeAccountsReader() - if err != nil { - return err + err := au.dbs.Snapshot(func(ctx context.Context, tx trackerdb.SnapshotScope) error { + ar, err0 := tx.MakeAccountsReader() + if err0 != nil { + return err0 } totals, err0 := ar.AccountsTotals(ctx, false) @@ -953,17 +953,17 @@ func (au *accountUpdates) initializeFromDisk(l ledgerForTracker, lastBalancesRou ledgerAccountsinitMicros.AddMicrosecondsSince(start, nil) if err != nil { - return + return err } au.accountsq, err = au.dbs.MakeAccountsOptimizedReader() if err != nil { - return + return err } hdr, err := l.BlockHdr(lastBalancesRound) if err != nil { - return + return err } au.versions = []protocol.ConsensusVersion{hdr.CurrentProtocol} @@ -983,7 +983,7 @@ func (au *accountUpdates) initializeFromDisk(l ledgerForTracker, lastBalancesRou au.baseResources.init(au.log, 0, 1) au.baseKVs.init(au.log, 0, 1) } - return + return nil } // newBlockImpl is the accountUpdates implementation of the ledgerTracker interface. This is the "internal" facing function @@ -1186,7 +1186,7 @@ func (au *accountUpdates) lookupLatest(addr basics.Address) (data basics.Account // use a cache of the most recent account state. ad = macct.data foundAccount = true - } else if pad, has := au.baseAccounts.read(addr); has && pad.Round == currentDbRound { + } else if pad, inLRU := au.baseAccounts.read(addr); inLRU && pad.Round == currentDbRound { // we don't technically need this, since it's already in the baseAccounts, however, writing this over // would ensure that we promote this field. au.baseAccounts.writePending(pad) @@ -1200,8 +1200,8 @@ func (au *accountUpdates) lookupLatest(addr basics.Address) (data basics.Account // check for resources modified in the past rounds, in the deltas for cidx, mr := range au.resources.getForAddress(addr) { - if err := addResource(cidx, rnd, mr.resource); err != nil { - return basics.AccountData{}, basics.Round(0), basics.MicroAlgos{}, err + if addErr := addResource(cidx, rnd, mr.resource); addErr != nil { + return basics.AccountData{}, basics.Round(0), basics.MicroAlgos{}, addErr } } @@ -1216,8 +1216,8 @@ func (au *accountUpdates) lookupLatest(addr basics.Address) (data basics.Account // would ensure that we promote this field. au.baseResources.writePending(prd, addr) if prd.AcctRef != nil { - if err := addResource(prd.Aidx, rnd, prd.AccountResource()); err != nil { - return basics.AccountData{}, basics.Round(0), basics.MicroAlgos{}, err + if addErr := addResource(prd.Aidx, rnd, prd.AccountResource()); addErr != nil { + return basics.AccountData{}, basics.Round(0), basics.MicroAlgos{}, addErr } } } @@ -1271,8 +1271,8 @@ func (au *accountUpdates) lookupLatest(addr basics.Address) (data basics.Account if resourceDbRound == currentDbRound { for _, pd := range persistedResources { au.baseResources.writePending(pd, addr) - if err := addResource(pd.Aidx, currentDbRound, pd.AccountResource()); err != nil { - return basics.AccountData{}, basics.Round(0), basics.MicroAlgos{}, err + if addErr := addResource(pd.Aidx, currentDbRound, pd.AccountResource()); addErr != nil { + return basics.AccountData{}, basics.Round(0), basics.MicroAlgos{}, addErr } } // We've found all the resources we could find for this address. @@ -1523,7 +1523,8 @@ func (au *accountUpdates) lookupWithoutRewards(rnd basics.Round, addr basics.Add } // getCreatorForRound returns the asset/app creator for a given asset/app index at a given round -func (au *accountUpdates) getCreatorForRound(rnd basics.Round, cidx basics.CreatableIndex, ctype basics.CreatableType, synchronized bool) (creator basics.Address, ok bool, err error) { +func (au *accountUpdates) getCreatorForRound(rnd basics.Round, cidx basics.CreatableIndex, ctype basics.CreatableType, synchronized bool) ( + /* creator */ basics.Address /* found */, bool, error) { unlock := false if synchronized { au.accountsMu.RLock() @@ -1539,6 +1540,7 @@ func (au *accountUpdates) getCreatorForRound(rnd basics.Round, cidx basics.Creat for { currentDbRound := au.cachedDBRound currentDeltaLen := len(au.deltas) + var err error offset, err = au.roundOffset(rnd) if err != nil { return basics.Address{}, false, err @@ -1573,6 +1575,8 @@ func (au *accountUpdates) getCreatorForRound(rnd basics.Round, cidx basics.Creat unlock = false } // Check the database + var ok bool + var creator basics.Address creator, ok, dbRound, err = au.accountsq.LookupCreator(cidx, ctype) if err != nil { return basics.Address{}, false, err diff --git a/ledger/apply/application.go b/ledger/apply/application.go index 3d03349ebe..b2716f76ce 100644 --- a/ledger/apply/application.go +++ b/ledger/apply/application.go @@ -385,7 +385,7 @@ func ApplicationCall(ac transactions.ApplicationCallTxnFields, header transactio // If this txn is going to set new programs (either for creation or // update), check that the programs are valid and not too expensive if ac.ApplicationID == 0 || ac.OnCompletion == transactions.UpdateApplicationOC { - err := transactions.CheckContractVersions(ac.ApprovalProgram, ac.ClearStateProgram, params, evalParams.Proto) + err = transactions.CheckContractVersions(ac.ApprovalProgram, ac.ClearStateProgram, params, evalParams.Proto) if err != nil { return err } @@ -401,9 +401,9 @@ func ApplicationCall(ac transactions.ApplicationCallTxnFields, header transactio // execute the ClearStateProgram, whose failures are ignored. if ac.OnCompletion == transactions.ClearStateOC { // Ensure that the user is already opted in - ok, err := balances.HasAppLocalState(header.Sender, appIdx) - if err != nil { - return err + ok, hasErr := balances.HasAppLocalState(header.Sender, appIdx) + if hasErr != nil { + return hasErr } if !ok { return fmt.Errorf("cannot clear state: %v is not currently opted in to app %d", header.Sender, appIdx) @@ -411,16 +411,16 @@ func ApplicationCall(ac transactions.ApplicationCallTxnFields, header transactio // If the app still exists, run the ClearStateProgram if exists { - pass, evalDelta, err := balances.StatefulEval(gi, evalParams, appIdx, params.ClearStateProgram) - if err != nil { + pass, evalDelta, evalErr := balances.StatefulEval(gi, evalParams, appIdx, params.ClearStateProgram) + if evalErr != nil { // Fail on non-logic eval errors and ignore LogicEvalError errors - if _, ok := err.(ledgercore.LogicEvalError); !ok { - return err + if _, ok := evalErr.(ledgercore.LogicEvalError); !ok { + return evalErr } } // We will have applied any changes if and only if we passed - if err == nil && pass { + if evalErr == nil && pass { // Fill in applyData, so that consumers don't have to implement a // stateful TEAL interpreter to apply state changes ad.EvalDelta = evalDelta diff --git a/ledger/apply/asset.go b/ledger/apply/asset.go index a29dd7ff55..f0701d28e9 100644 --- a/ledger/apply/asset.go +++ b/ledger/apply/asset.go @@ -110,9 +110,9 @@ func AssetConfig(cc transactions.AssetConfigTxnFields, header transactions.Heade } // Re-configuration and destroying must be done by the manager key. - params, creator, err := getParams(balances, cc.ConfigAsset) - if err != nil { - return err + params, creator, paramsErr := getParams(balances, cc.ConfigAsset) + if paramsErr != nil { + return paramsErr } if params.Manager.IsZero() || (header.Sender != params.Manager) { @@ -186,9 +186,9 @@ func AssetConfig(cc transactions.AssetConfigTxnFields, header transactions.Heade params.Clawback = cc.AssetParams.Clawback } - err = balances.PutAssetParams(creator, cc.ConfigAsset, params) - if err != nil { - return err + paramsErr = balances.PutAssetParams(creator, cc.ConfigAsset, params) + if paramsErr != nil { + return paramsErr } } diff --git a/ledger/catchpointtracker.go b/ledger/catchpointtracker.go index 26e7972e9d..7cd515a919 100644 --- a/ledger/catchpointtracker.go +++ b/ledger/catchpointtracker.go @@ -948,18 +948,17 @@ func (ct *catchpointTracker) close() { } // accountsUpdateBalances applies the given compactAccountDeltas to the merkle trie -func (ct *catchpointTracker) accountsUpdateBalances(accountsDeltas compactAccountDeltas, resourcesDeltas compactResourcesDeltas, kvDeltas map[string]modifiedKvValue, oldBase basics.Round, newBase basics.Round) (err error) { +func (ct *catchpointTracker) accountsUpdateBalances(accountsDeltas compactAccountDeltas, resourcesDeltas compactResourcesDeltas, kvDeltas map[string]modifiedKvValue, oldBase basics.Round, newBase basics.Round) error { if !ct.catchpointEnabled() { return nil } - var added, deleted bool accumulatedChanges := 0 for i := 0; i < accountsDeltas.len(); i++ { delta := accountsDeltas.getByIdx(i) if !delta.oldAcct.AccountData.IsEmpty() { deleteHash := trackerdb.AccountHashBuilderV6(delta.address, &delta.oldAcct.AccountData, protocol.Encode(&delta.oldAcct.AccountData)) - deleted, err = ct.balancesTrie.Delete(deleteHash) + deleted, err := ct.balancesTrie.Delete(deleteHash) if err != nil { return fmt.Errorf("failed to delete hash '%s' from merkle trie for account %v: %w", hex.EncodeToString(deleteHash), delta.address, err) } @@ -972,7 +971,7 @@ func (ct *catchpointTracker) accountsUpdateBalances(accountsDeltas compactAccoun if !delta.newAcct.IsEmpty() { addHash := trackerdb.AccountHashBuilderV6(delta.address, &delta.newAcct, protocol.Encode(&delta.newAcct)) - added, err = ct.balancesTrie.Add(addHash) + added, err := ct.balancesTrie.Add(addHash) if err != nil { return fmt.Errorf("attempted to add duplicate hash '%s' to merkle trie for account %v: %w", hex.EncodeToString(addHash), delta.address, err) } @@ -992,7 +991,7 @@ func (ct *catchpointTracker) accountsUpdateBalances(accountsDeltas compactAccoun if err != nil { return err } - deleted, err = ct.balancesTrie.Delete(deleteHash) + deleted, err := ct.balancesTrie.Delete(deleteHash) if err != nil { return fmt.Errorf("failed to delete resource hash '%s' from merkle trie for account %v: %w", hex.EncodeToString(deleteHash), addr, err) } @@ -1008,7 +1007,7 @@ func (ct *catchpointTracker) accountsUpdateBalances(accountsDeltas compactAccoun if err != nil { return err } - added, err = ct.balancesTrie.Add(addHash) + added, err := ct.balancesTrie.Add(addHash) if err != nil { return fmt.Errorf("attempted to add duplicate resource hash '%s' to merkle trie for account %v: %w", hex.EncodeToString(addHash), addr, err) } @@ -1030,7 +1029,7 @@ func (ct *catchpointTracker) accountsUpdateBalances(accountsDeltas compactAccoun continue // changed back within the delta span } deleteHash := trackerdb.KvHashBuilderV6(key, mv.oldData) - deleted, err = ct.balancesTrie.Delete(deleteHash) + deleted, err := ct.balancesTrie.Delete(deleteHash) if err != nil { return fmt.Errorf("failed to delete kv hash '%s' from merkle trie for key %v: %w", hex.EncodeToString(deleteHash), key, err) } @@ -1043,7 +1042,7 @@ func (ct *catchpointTracker) accountsUpdateBalances(accountsDeltas compactAccoun if mv.data != nil { addHash := trackerdb.KvHashBuilderV6(key, mv.data) - added, err = ct.balancesTrie.Add(addHash) + added, err := ct.balancesTrie.Add(addHash) if err != nil { return fmt.Errorf("attempted to add duplicate kv hash '%s' from merkle trie for key %v: %w", hex.EncodeToString(addHash), key, err) } @@ -1057,15 +1056,16 @@ func (ct *catchpointTracker) accountsUpdateBalances(accountsDeltas compactAccoun // write it all to disk. var cstats merkletrie.CommitStats + var commitErr error if accumulatedChanges > 0 { - cstats, err = ct.balancesTrie.Commit() + cstats, commitErr = ct.balancesTrie.Commit() } if ct.log.GetTelemetryEnabled() { root, rootErr := ct.balancesTrie.RootHash() if rootErr != nil { ct.log.Errorf("accountsUpdateBalances: error retrieving balances trie root: %v", rootErr) - return + return commitErr } ct.log.EventWithDetails(telemetryspec.Accounts, telemetryspec.CatchpointRootUpdateEvent, telemetryspec.CatchpointRootUpdateEventDetails{ Root: root.String(), @@ -1082,7 +1082,7 @@ func (ct *catchpointTracker) accountsUpdateBalances(accountsDeltas compactAccoun }) } - return + return commitErr } // IsWritingCatchpointDataFile returns true iff a (first stage) catchpoint data file @@ -1207,21 +1207,20 @@ func (ct *catchpointTracker) recordFirstStageInfo(ctx context.Context, tx tracke return err } - { - mc, err := tx.MakeMerkleCommitter(false) - if err != nil { - return err - } - if ct.balancesTrie == nil { - trie, err := merkletrie.MakeTrie(mc, trackerdb.TrieMemoryConfig) - if err != nil { - return err - } - ct.balancesTrie = trie - } else { - ct.balancesTrie.SetCommitter(mc) + mc, err := tx.MakeMerkleCommitter(false) + if err != nil { + return err + } + if ct.balancesTrie == nil { + trie, trieErr := merkletrie.MakeTrie(mc, trackerdb.TrieMemoryConfig) + if trieErr != nil { + return trieErr } + ct.balancesTrie = trie + } else { + ct.balancesTrie.SetCommitter(mc) } + trieBalancesHash, err := ct.balancesTrie.RootHash() if err != nil { return err @@ -1330,28 +1329,28 @@ func (ct *catchpointTracker) GetCatchpointStream(round basics.Round) (ReadCloseS } if dbFileName != "" { catchpointPath := filepath.Join(ct.dbDirectory, dbFileName) - file, err := os.OpenFile(catchpointPath, os.O_RDONLY, 0666) - if err == nil && file != nil { + file, openErr := os.OpenFile(catchpointPath, os.O_RDONLY, 0666) + if openErr == nil && file != nil { return &readCloseSizer{ReadCloser: file, size: fileSize}, nil } // else, see if this is a file-not-found error - if os.IsNotExist(err) { + if os.IsNotExist(openErr) { // the database told us that we have this file.. but we couldn't find it. // delete it from the database. - crw, err := ct.dbs.MakeCatchpointReaderWriter() - if err != nil { - return nil, err + crw, err2 := ct.dbs.MakeCatchpointReaderWriter() + if err2 != nil { + return nil, err2 } - err = ct.recordCatchpointFile(context.Background(), crw, round, "", 0) - if err != nil { - ct.log.Warnf("catchpointTracker.GetCatchpointStream() unable to delete missing catchpoint entry: %v", err) - return nil, err + err2 = ct.recordCatchpointFile(context.Background(), crw, round, "", 0) + if err2 != nil { + ct.log.Warnf("catchpointTracker.GetCatchpointStream() unable to delete missing catchpoint entry: %v", err2) + return nil, err2 } return nil, ledgercore.ErrNoEntry{} } // it's some other error. - return nil, fmt.Errorf("catchpointTracker.GetCatchpointStream() unable to open catchpoint file '%s' %v", catchpointPath, err) + return nil, fmt.Errorf("catchpointTracker.GetCatchpointStream() unable to open catchpoint file '%s' %v", catchpointPath, openErr) } // if the database doesn't know about that round, see if we have that file anyway: @@ -1436,28 +1435,28 @@ func (ct *catchpointTracker) initializeHashes(ctx context.Context, tx trackerdb. pendingTrieHashes := 0 totalOrderedAccounts := 0 for { - accts, processedRows, err := accountBuilderIt.Next(ctx) - if err == sql.ErrNoRows { + accts, processedRows, itErr := accountBuilderIt.Next(ctx) + if itErr == sql.ErrNoRows { // the account builder would return sql.ErrNoRows when no more data is available. break - } else if err != nil { - return err + } else if itErr != nil { + return itErr } if len(accts) > 0 { trieHashCount += len(accts) pendingTrieHashes += len(accts) for _, acct := range accts { - added, err := trie.Add(acct.Digest) - if err != nil { - return fmt.Errorf("initializeHashes was unable to add acct to trie: %v", err) + added, addErr := trie.Add(acct.Digest) + if addErr != nil { + return fmt.Errorf("initializeHashes was unable to add acct to trie: %v", addErr) } if !added { // we need to translate the "addrid" into actual account address so that // we can report the failure. - addr, err := arw.LookupAccountAddressFromAddressID(ctx, acct.AccountRef) - if err != nil { - ct.log.Warnf("initializeHashes attempted to add duplicate acct hash '%s' to merkle trie for account id %d : %v", hex.EncodeToString(acct.Digest), acct.AccountRef, err) + addr, lErr := arw.LookupAccountAddressFromAddressID(ctx, acct.AccountRef) + if lErr != nil { + ct.log.Warnf("initializeHashes attempted to add duplicate acct hash '%s' to merkle trie for account id %d : %v", hex.EncodeToString(acct.Digest), acct.AccountRef, lErr) } else { ct.log.Warnf("initializeHashes attempted to add duplicate acct hash '%s' to merkle trie for account %v", hex.EncodeToString(acct.Digest), addr) } @@ -1505,16 +1504,16 @@ func (ct *catchpointTracker) initializeHashes(ctx context.Context, tx trackerdb. } defer kvs.Close() for kvs.Next() { - k, v, err := kvs.KeyValue() - if err != nil { - return err + k, v, err2 := kvs.KeyValue() + if err2 != nil { + return err2 } hash := trackerdb.KvHashBuilderV6(string(k), v) trieHashCount++ pendingTrieHashes++ - added, err := trie.Add(hash) - if err != nil { - return fmt.Errorf("initializeHashes was unable to add kv (key=%s) to trie: %v", hex.EncodeToString(k), err) + added, err2 := trie.Add(hash) + if err2 != nil { + return fmt.Errorf("initializeHashes was unable to add kv (key=%s) to trie: %v", hex.EncodeToString(k), err2) } if !added { ct.log.Warnf("initializeHashes attempted to add duplicate kv hash '%s' to merkle trie for key %s", hex.EncodeToString(hash), k) @@ -1522,9 +1521,9 @@ func (ct *catchpointTracker) initializeHashes(ctx context.Context, tx trackerdb. if pendingTrieHashes >= trieRebuildCommitFrequency { // this trie Evict will commit using the current transaction. // if anything goes wrong, it will still get rolled back. - _, err = trie.Evict(true) - if err != nil { - return fmt.Errorf("initializeHashes was unable to commit changes to trie: %v", err) + _, err2 = trie.Evict(true) + if err2 != nil { + return fmt.Errorf("initializeHashes was unable to commit changes to trie: %v", err2) } pendingTrieHashes = 0 } diff --git a/ledger/catchupaccessor.go b/ledger/catchupaccessor.go index ec33f2ac56..b38fa609f3 100644 --- a/ledger/catchupaccessor.go +++ b/ledger/catchupaccessor.go @@ -603,9 +603,9 @@ func (c *catchpointCatchupAccessorImpl) processStagingBalances(ctx context.Conte wg.Add(1) go func() { defer wg.Done() - start := time.Now() + writeBalStart := time.Now() errBalances = c.stagingWriter.writeBalances(ctx, normalizedAccountBalances) - durBalances = time.Since(start) + durBalances = time.Since(writeBalStart) }() // on a in-memory database, wait for the writer to finish before starting the new writer @@ -627,9 +627,9 @@ func (c *catchpointCatchupAccessorImpl) processStagingBalances(ctx context.Conte } } if hasCreatables { - start := time.Now() + writeStart := time.Now() errCreatables = c.stagingWriter.writeCreatables(ctx, normalizedAccountBalances) - durCreatables = time.Since(start) + durCreatables = time.Since(writeStart) } }() @@ -642,9 +642,9 @@ func (c *catchpointCatchupAccessorImpl) processStagingBalances(ctx context.Conte wg.Add(1) go func() { defer wg.Done() - start := time.Now() + writeHashesStart := time.Now() errHashes = c.stagingWriter.writeHashes(ctx, normalizedAccountBalances) - durHashes = time.Since(start) + durHashes = time.Since(writeHashesStart) }() // on a in-memory database, wait for the writer to finish before starting the new writer @@ -657,9 +657,9 @@ func (c *catchpointCatchupAccessorImpl) processStagingBalances(ctx context.Conte go func() { defer wg.Done() - start := time.Now() + writeKVsStart := time.Now() errKVs = c.stagingWriter.writeKVs(ctx, chunkKVs) - durKVs = time.Since(start) + durKVs = time.Since(writeKVsStart) }() wg.Wait() @@ -754,7 +754,7 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro defer wg.Done() defer close(writerQueue) - err := dbs.Snapshot(func(transactionCtx context.Context, tx trackerdb.SnapshotScope) (err error) { + dbErr := dbs.Snapshot(func(transactionCtx context.Context, tx trackerdb.SnapshotScope) (err error) { it := tx.MakeCatchpointPendingHashesIterator(trieRebuildAccountChunkSize) var hashes [][]byte for { @@ -778,8 +778,8 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro db.ResetTransactionWarnDeadline(transactionCtx, tx, time.Now().Add(5*time.Second)) return err }) - if err != nil { - errChan <- err + if dbErr != nil { + errChan <- dbErr } }() @@ -792,7 +792,7 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro accountHashesWritten, kvHashesWritten := uint64(0), uint64(0) var mc trackerdb.MerkleCommitter - err := dbs.Transaction(func(transactionCtx context.Context, tx trackerdb.TransactionScope) (err error) { + txErr := dbs.Transaction(func(transactionCtx context.Context, tx trackerdb.TransactionScope) (err error) { // create the merkle trie for the balances mc, err = tx.MakeMerkleCommitter(true) if err != nil { @@ -802,8 +802,8 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro trie, err = merkletrie.MakeTrie(mc, trackerdb.TrieMemoryConfig) return err }) - if err != nil { - errChan <- err + if txErr != nil { + errChan <- txErr return } @@ -821,7 +821,7 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro continue } - err = dbs.Transaction(func(transactionCtx context.Context, tx trackerdb.TransactionScope) (err error) { + txErr = dbs.Transaction(func(transactionCtx context.Context, tx trackerdb.TransactionScope) (err error) { mc, err = tx.MakeMerkleCommitter(true) if err != nil { return @@ -846,12 +846,12 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro return nil }) - if err != nil { + if txErr != nil { break } if uncommitedHashesCount >= trieRebuildCommitFrequency { - err = dbs.Transaction(func(transactionCtx context.Context, tx trackerdb.TransactionScope) (err error) { + txErr = dbs.Transaction(func(transactionCtx context.Context, tx trackerdb.TransactionScope) (err error) { // set a long 30-second window for the evict before warning is generated. _, err = tx.ResetTransactionWarnDeadline(transactionCtx, time.Now().Add(30*time.Second)) if err != nil { @@ -869,7 +869,7 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro uncommitedHashesCount = 0 return nil }) - if err != nil { + if txErr != nil { keepWriting = false continue } @@ -879,12 +879,12 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro progressUpdates(accountHashesWritten, kvHashesWritten) } } - if err != nil { - errChan <- err + if txErr != nil { + errChan <- txErr return } if uncommitedHashesCount > 0 { - err = dbs.Transaction(func(transactionCtx context.Context, tx trackerdb.TransactionScope) (err error) { + txErr = dbs.Transaction(func(transactionCtx context.Context, tx trackerdb.TransactionScope) (err error) { // set a long 30-second window for the evict before warning is generated. _, err = tx.ResetTransactionWarnDeadline(transactionCtx, time.Now().Add(30*time.Second)) if err != nil { @@ -900,8 +900,8 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro }) } - if err != nil { - errChan <- err + if txErr != nil { + errChan <- txErr } }() diff --git a/ledger/eval/eval.go b/ledger/eval/eval.go index 62533fe14f..bd6f4ed84f 100644 --- a/ledger/eval/eval.go +++ b/ledger/eval/eval.go @@ -157,10 +157,10 @@ func makeRoundCowBase(l LedgerForCowBase, rnd basics.Round, txnCount uint64, sta } func (x *roundCowBase) getCreator(cidx basics.CreatableIndex, ctype basics.CreatableType) (basics.Address, bool, error) { - creatable := creatable{cindex: cidx, ctype: ctype} + c := creatable{cindex: cidx, ctype: ctype} - if foundAddress, ok := x.creators[creatable]; ok { - return foundAddress.address, foundAddress.exists, nil + if fa, ok := x.creators[c]; ok { + return fa.address, fa.exists, nil } address, exists, err := x.l.GetCreatorForRound(x.rnd, cidx, ctype) @@ -169,7 +169,7 @@ func (x *roundCowBase) getCreator(cidx basics.CreatableIndex, ctype basics.Creat "roundCowBase.getCreator() cidx: %d ctype: %v err: %w", cidx, ctype, err) } - x.creators[creatable] = foundAddress{address: address, exists: exists} + x.creators[c] = foundAddress{address: address, exists: exists} return address, exists, nil } @@ -732,9 +732,9 @@ func StartEvaluator(l LedgerForEvaluator, hdr bookkeeping.BlockHeader, evalOpts eval.state = makeRoundCowState(base, eval.block.BlockHeader, proto, eval.prevHeader.TimeStamp, prevTotals, evalOpts.PaysetHint) if evalOpts.Validate { - err := eval.block.BlockHeader.PreCheck(eval.prevHeader) - if err != nil { - return nil, err + preCheckErr := eval.block.BlockHeader.PreCheck(eval.prevHeader) + if preCheckErr != nil { + return nil, preCheckErr } // Check that the rewards rate, level and residue match expected values @@ -1090,16 +1090,16 @@ func (eval *BlockEvaluator) transaction(txn transactions.SignedTxn, evalParams * } // Transaction already in the ledger? - err := cow.checkDup(txn.Txn.First(), txn.Txn.Last(), txid, ledgercore.Txlease{Sender: txn.Txn.Sender, Lease: txn.Txn.Lease}) + err = cow.checkDup(txn.Txn.First(), txn.Txn.Last(), txid, ledgercore.Txlease{Sender: txn.Txn.Sender, Lease: txn.Txn.Lease}) if err != nil { return err } // Does the address that authorized the transaction actually match whatever address the sender has rekeyed to? // i.e., the sig/lsig/msig was checked against the txn.Authorizer() address, but does this match the sender's balrecord.AuthAddr? - acctdata, err := cow.lookup(txn.Txn.Sender) - if err != nil { - return err + acctdata, lookupErr := cow.lookup(txn.Txn.Sender) + if lookupErr != nil { + return lookupErr } correctAuthorizer := acctdata.AuthAddr if (correctAuthorizer == basics.Address{}) { @@ -1293,9 +1293,9 @@ func (eval *BlockEvaluator) endOfBlock() error { if eval.validate { // check commitments - txnRoot, err := eval.block.PaysetCommit() - if err != nil { - return err + txnRoot, err2 := eval.block.PaysetCommit() + if err2 != nil { + return err2 } if txnRoot != eval.block.TxnCommitments { return fmt.Errorf("txn root wrong: %v != %v", txnRoot, eval.block.TxnCommitments) @@ -1309,9 +1309,9 @@ func (eval *BlockEvaluator) endOfBlock() error { return fmt.Errorf("txn count wrong: %d != %d", eval.block.TxnCounter, expectedTxnCount) } - expectedVoters, expectedVotersWeight, err := eval.stateProofVotersAndTotal() - if err != nil { - return err + expectedVoters, expectedVotersWeight, err2 := eval.stateProofVotersAndTotal() + if err2 != nil { + return err2 } if !eval.block.StateProofTracking[protocol.StateProofBasic].StateProofVotersCommitment.IsEqual(expectedVoters) { return fmt.Errorf("StateProofVotersCommitment wrong: %v != %v", eval.block.StateProofTracking[protocol.StateProofBasic].StateProofVotersCommitment, expectedVoters) @@ -1666,10 +1666,10 @@ transactionGroupLoop: } case <-ctx.Done(): return ledgercore.StateDelta{}, ctx.Err() - case err, open := <-txvalidator.done: + case doneErr, open := <-txvalidator.done: // if we're not validating, then `txvalidator.done` would be nil, in which case this case statement would never be executed. - if open && err != nil { - return ledgercore.StateDelta{}, err + if open && doneErr != nil { + return ledgercore.StateDelta{}, doneErr } } } diff --git a/ledger/eval/prefetcher/prefetcher.go b/ledger/eval/prefetcher/prefetcher.go index e00d78f701..40702b0088 100644 --- a/ledger/eval/prefetcher/prefetcher.go +++ b/ledger/eval/prefetcher/prefetcher.go @@ -200,16 +200,16 @@ func loadAccountsAddAccountTask(addr *basics.Address, wt *groupTask, accountTask return } if task, have := accountTasks[*addr]; !have { - task := &preloaderTask{ + newTask := &preloaderTask{ address: addr, groupTasks: make([]*groupTask, 1, 4), groupTasksIndices: make([]int, 1, 4), } - task.groupTasks[0] = wt - task.groupTasksIndices[0] = wt.balancesCount + newTask.groupTasks[0] = wt + newTask.groupTasksIndices[0] = wt.balancesCount - accountTasks[*addr] = task - queue.enqueue(task) + accountTasks[*addr] = newTask + queue.enqueue(newTask) } else { task.groupTasks = append(task.groupTasks, wt) task.groupTasksIndices = append(task.groupTasksIndices, wt.balancesCount) @@ -228,18 +228,18 @@ func loadAccountsAddResourceTask(addr *basics.Address, cidx basics.CreatableInde key.address = *addr } if task, have := resourceTasks[key]; !have { - task := &preloaderTask{ + newTask := &preloaderTask{ address: addr, groupTasks: make([]*groupTask, 1, 4), groupTasksIndices: make([]int, 1, 4), creatableIndex: cidx, creatableType: ctype, } - task.groupTasks[0] = wt - task.groupTasksIndices[0] = wt.resourcesCount + newTask.groupTasks[0] = wt + newTask.groupTasksIndices[0] = wt.resourcesCount - resourceTasks[key] = task - queue.enqueue(task) + resourceTasks[key] = newTask + queue.enqueue(newTask) } else { task.groupTasks = append(task.groupTasks, wt) task.groupTasksIndices = append(task.groupTasksIndices, wt.resourcesCount) diff --git a/ledger/store/trackerdb/sqlitedriver/accountsV2.go b/ledger/store/trackerdb/sqlitedriver/accountsV2.go index 3ffb069999..12945dcf30 100644 --- a/ledger/store/trackerdb/sqlitedriver/accountsV2.go +++ b/ledger/store/trackerdb/sqlitedriver/accountsV2.go @@ -61,15 +61,15 @@ func (r *accountsV2Reader) Testing() trackerdb.TestAccountsReaderExt { return r } -func (r *accountsV2Reader) getOrPrepare(queryString string) (stmt *sql.Stmt, err error) { +func (r *accountsV2Reader) getOrPrepare(queryString string) (*sql.Stmt, error) { // fetch statement (use the query as the key) if stmt, ok := r.preparedStatements[queryString]; ok { return stmt, nil } // we do not have it, prepare it - stmt, err = r.q.Prepare(queryString) + stmt, err := r.q.Prepare(queryString) if err != nil { - return + return nil, err } // cache the statement r.preparedStatements[queryString] = stmt diff --git a/ledger/store/trackerdb/sqlitedriver/orderedAccountsIter.go b/ledger/store/trackerdb/sqlitedriver/orderedAccountsIter.go index 2e2c40dbb9..cf927042c5 100644 --- a/ledger/store/trackerdb/sqlitedriver/orderedAccountsIter.go +++ b/ledger/store/trackerdb/sqlitedriver/orderedAccountsIter.go @@ -153,12 +153,12 @@ func (iterator *orderedAccountsIter) Next(ctx context.Context) (acct []trackerdb resCb := func(addr basics.Address, cidx basics.CreatableIndex, resData *trackerdb.ResourcesData, encodedResourceData []byte, lastResource bool) error { if resData != nil { - hash, err := trackerdb.ResourcesHashBuilderV6(resData, addr, cidx, resData.UpdateRound, encodedResourceData) - if err != nil { - return err + hash, err2 := trackerdb.ResourcesHashBuilderV6(resData, addr, cidx, resData.UpdateRound, encodedResourceData) + if err2 != nil { + return err2 } - _, err = iterator.insertStmt.ExecContext(ctx, lastAddrID, hash) - return err + _, err2 = iterator.insertStmt.ExecContext(ctx, lastAddrID, hash) + return err2 } return nil } @@ -418,7 +418,7 @@ func processAllResources( count++ if resourceCount > 0 && count == resourceCount { // last resource to be included in chunk - err := callback(addr, aidx, &resData, buf, true) + err = callback(addr, aidx, &resData, buf, true) return pendingResourceRow{}, count, err } err = callback(addr, aidx, &resData, buf, false) diff --git a/ledger/store/trackerdb/sqlitedriver/schema.go b/ledger/store/trackerdb/sqlitedriver/schema.go index e99e9c68e2..d1688721a0 100644 --- a/ledger/store/trackerdb/sqlitedriver/schema.go +++ b/ledger/store/trackerdb/sqlitedriver/schema.go @@ -253,7 +253,7 @@ func accountsAddNormalizedBalance(tx *sql.Tx, proto config.ConsensusParams) erro } for _, stmt := range createOnlineAccountIndex { - _, err := tx.Exec(stmt) + _, err = tx.Exec(stmt) if err != nil { return err } @@ -497,12 +497,12 @@ func performResourceTableMigration(ctx context.Context, tx *sql.Tx, log func(pro return err } insertResourceCallback := func(ctx context.Context, rowID int64, cidx basics.CreatableIndex, rd *trackerdb.ResourcesData) error { - var err error + var err0 error if rd != nil { encodedData := protocol.Encode(rd) - _, err = insertResources.ExecContext(ctx, rowID, cidx, encodedData) + _, err0 = insertResources.ExecContext(ctx, rowID, cidx, encodedData) } - return err + return err0 } err = trackerdb.AccountDataResources(ctx, &accountData, rowID, insertResourceCallback) if err != nil { @@ -543,13 +543,13 @@ func performTxTailTableMigration(ctx context.Context, tx *sql.Tx, blockDb db.Acc // when migrating there is only MaxTxnLife blocks in the block DB // since the original txTail.commmittedUpTo preserved only (rnd+1)-MaxTxnLife = 1000 blocks back err = blockDb.Atomic(func(ctx context.Context, blockTx *sql.Tx) error { - latestBlockRound, err := blockdb.BlockLatest(blockTx) - if err != nil { - return fmt.Errorf("latest block number cannot be retrieved : %w", err) + latestBlockRound, blockErr := blockdb.BlockLatest(blockTx) + if blockErr != nil { + return fmt.Errorf("latest block number cannot be retrieved : %w", blockErr) } - latestHdr, err := blockdb.BlockGetHdr(blockTx, dbRound) - if err != nil { - return fmt.Errorf("latest block header %d cannot be retrieved : %w", dbRound, err) + latestHdr, hdrErr := blockdb.BlockGetHdr(blockTx, dbRound) + if hdrErr != nil { + return fmt.Errorf("latest block header %d cannot be retrieved : %w", dbRound, hdrErr) } proto := config.Consensus[latestHdr.CurrentProtocol] @@ -563,7 +563,7 @@ func performTxTailTableMigration(ctx context.Context, tx *sql.Tx, blockDb db.Acc if firstRound == basics.Round(0) { firstRound++ } - if _, err := blockdb.BlockGet(blockTx, firstRound); err != nil { + if _, getErr := blockdb.BlockGet(blockTx, firstRound); getErr != nil { // looks like not catchpoint but a regular migration, start from maxTxnLife + deeperBlockHistory back firstRound = (latestBlockRound + 1).SubSaturate(maxTxnLife + deeperBlockHistory) if firstRound == basics.Round(0) { @@ -572,14 +572,14 @@ func performTxTailTableMigration(ctx context.Context, tx *sql.Tx, blockDb db.Acc } tailRounds := make([][]byte, 0, maxTxnLife) for rnd := firstRound; rnd <= dbRound; rnd++ { - blk, err := blockdb.BlockGet(blockTx, rnd) - if err != nil { - return fmt.Errorf("block for round %d ( %d - %d ) cannot be retrieved : %w", rnd, firstRound, dbRound, err) + blk, getErr := blockdb.BlockGet(blockTx, rnd) + if getErr != nil { + return fmt.Errorf("block for round %d ( %d - %d ) cannot be retrieved : %w", rnd, firstRound, dbRound, getErr) } - tail, err := trackerdb.TxTailRoundFromBlock(blk) - if err != nil { - return err + tail, tErr := trackerdb.TxTailRoundFromBlock(blk) + if tErr != nil { + return tErr } encodedTail, _ := tail.Encode() @@ -607,9 +607,9 @@ func performOnlineRoundParamsTailMigration(ctx context.Context, tx *sql.Tx, bloc currentProto = initProto } else { err = blockDb.Atomic(func(ctx context.Context, blockTx *sql.Tx) error { - hdr, err := blockdb.BlockGetHdr(blockTx, rnd) - if err != nil { - return err + hdr, hdrErr := blockdb.BlockGetHdr(blockTx, rnd) + if hdrErr != nil { + return hdrErr } currentProto = hdr.CurrentProtocol return nil @@ -779,18 +779,18 @@ func performOnlineAccountsTableMigration(ctx context.Context, tx *sql.Tx, progre } for addr, state := range acctRehash { deleteHash := trackerdb.AccountHashBuilderV6(addr, &state.old, state.oldEnc) - deleted, err := trie.Delete(deleteHash) - if err != nil { - return fmt.Errorf("performOnlineAccountsTableMigration failed to delete hash '%s' from merkle trie for account %v: %w", hex.EncodeToString(deleteHash), addr, err) + deleted, delErr := trie.Delete(deleteHash) + if delErr != nil { + return fmt.Errorf("performOnlineAccountsTableMigration failed to delete hash '%s' from merkle trie for account %v: %w", hex.EncodeToString(deleteHash), addr, delErr) } if !deleted && log != nil { log.Warnf("performOnlineAccountsTableMigration failed to delete hash '%s' from merkle trie for account %v", hex.EncodeToString(deleteHash), addr) } addHash := trackerdb.AccountHashBuilderV6(addr, &state.new, state.newEnc) - added, err := trie.Add(addHash) - if err != nil { - return fmt.Errorf("performOnlineAccountsTableMigration attempted to add duplicate hash '%s' to merkle trie for account %v: %w", hex.EncodeToString(addHash), addr, err) + added, addErr := trie.Add(addHash) + if addErr != nil { + return fmt.Errorf("performOnlineAccountsTableMigration attempted to add duplicate hash '%s' to merkle trie for account %v: %w", hex.EncodeToString(addHash), addr, addErr) } if !added && log != nil { log.Warnf("performOnlineAccountsTableMigration attempted to add duplicate hash '%s' to merkle trie for account %v", hex.EncodeToString(addHash), addr) @@ -809,9 +809,9 @@ func performOnlineAccountsTableMigration(ctx context.Context, tx *sql.Tx, progre // and optionally returns list of addresses that were eliminated func removeEmptyAccountData(tx *sql.Tx, queryAddresses bool) (num int64, addresses []basics.Address, err error) { if queryAddresses { - rows, err := tx.Query("SELECT address FROM accountbase where length(data) = 1 and data = x'80'") // empty AccountData is 0x80 - if err != nil { - return 0, nil, err + rows, qErr := tx.Query("SELECT address FROM accountbase where length(data) = 1 and data = x'80'") // empty AccountData is 0x80 + if qErr != nil { + return 0, nil, qErr } defer rows.Close() @@ -909,13 +909,13 @@ func reencodeAccounts(ctx context.Context, tx *sql.Tx) (modifiedAccounts uint, e } // we need to update the encoded data. - result, err := updateStmt.ExecContext(ctx, reencodedAccountData, addrbuf) - if err != nil { - return 0, err + result, rowsErr := updateStmt.ExecContext(ctx, reencodedAccountData, addrbuf) + if rowsErr != nil { + return 0, rowsErr } - rowsUpdated, err := result.RowsAffected() - if err != nil { - return 0, err + rowsUpdated, rowsErr := result.RowsAffected() + if rowsErr != nil { + return 0, rowsErr } if rowsUpdated != 1 { return 0, fmt.Errorf("failed to update account %v, number of rows updated was %d instead of 1", addr, rowsUpdated) diff --git a/ledger/store/trackerdb/sqlitedriver/sql.go b/ledger/store/trackerdb/sqlitedriver/sql.go index 1c7becb916..c4f1639bd4 100644 --- a/ledger/store/trackerdb/sqlitedriver/sql.go +++ b/ledger/store/trackerdb/sqlitedriver/sql.go @@ -552,7 +552,7 @@ func (qs *onlineAccountsDbQueries) LookupOnlineHistory(addr basics.Address) (res var buf []byte data := trackerdb.PersistedOnlineAccountData{} var rowid int64 - err := rows.Scan(&rowid, &data.UpdRound, &rnd, &buf) + err = rows.Scan(&rowid, &data.UpdRound, &rnd, &buf) if err != nil { return err } @@ -564,7 +564,7 @@ func (qs *onlineAccountsDbQueries) LookupOnlineHistory(addr basics.Address) (res data.Addr = addr result = append(result, data) } - return err + return nil }) return } diff --git a/ledger/store/trackerdb/sqlitedriver/trackerdbV2.go b/ledger/store/trackerdb/sqlitedriver/trackerdbV2.go index 1940e54a21..3a052800ec 100644 --- a/ledger/store/trackerdb/sqlitedriver/trackerdbV2.go +++ b/ledger/store/trackerdb/sqlitedriver/trackerdbV2.go @@ -310,9 +310,9 @@ func (tu *trackerDBSchemaInitializer) upgradeDatabaseSchema4(ctx context.Context var totalHashesDeleted int for _, addr := range addresses { hash := trackerdb.AccountHashBuilder(addr, basics.AccountData{}, []byte{0x80}) - deleted, err := trie.Delete(hash) - if err != nil { - tu.log.Errorf("upgradeDatabaseSchema4: failed to delete hash '%s' from merkle trie for account %v: %v", hex.EncodeToString(hash), addr, err) + deleted, delErr := trie.Delete(hash) + if delErr != nil { + tu.log.Errorf("upgradeDatabaseSchema4: failed to delete hash '%s' from merkle trie for account %v: %v", hex.EncodeToString(hash), addr, delErr) } else { if !deleted { tu.log.Warnf("upgradeDatabaseSchema4: failed to delete hash '%s' from merkle trie for account %v", hex.EncodeToString(hash), addr) diff --git a/netdeploy/networkTemplate.go b/netdeploy/networkTemplate.go index 865ad9c30a..1a140e74d6 100644 --- a/netdeploy/networkTemplate.go +++ b/netdeploy/networkTemplate.go @@ -141,9 +141,9 @@ func (t NetworkTemplate) createNodeDirectories(targetFolder string, binDir strin return } - stdout, stderr, err := util.ExecAndCaptureOutput(importKeysCmd, "account", "importrootkey", "-w", string(libgoal.UnencryptedWalletName), "-d", nodeDir) - if err != nil { - return nil, nil, fmt.Errorf("goal account importrootkey failed: %w\nstdout: %s\nstderr: %s", err, stdout, stderr) + stdout, stderr, execErr := util.ExecAndCaptureOutput(importKeysCmd, "account", "importrootkey", "-w", string(libgoal.UnencryptedWalletName), "-d", nodeDir) + if execErr != nil { + return nil, nil, fmt.Errorf("goal account importrootkey failed: %w\nstdout: %s\nstderr: %s", execErr, stdout, stderr) } } diff --git a/network/wsNetwork.go b/network/wsNetwork.go index 7339bbde61..0679adda54 100644 --- a/network/wsNetwork.go +++ b/network/wsNetwork.go @@ -2234,13 +2234,13 @@ func (wn *WebsocketNetwork) tryConnect(addr, gossipAddr string) { // if we abort before making a wsPeer this cleanup logic will close the connection closeEarly := func(msg string) { deadline := time.Now().Add(peerDisconnectionAckDuration) - err := conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseProtocolError, msg), deadline) - if err != nil { - wn.log.Infof("tryConnect: failed to write CloseMessage to connection for %s", conn.RemoteAddr().String()) + err2 := conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseProtocolError, msg), deadline) + if err2 != nil { + wn.log.Infof("tryConnect: failed to write CloseMessage to connection for %s: %v", conn.RemoteAddr().String(), err2) } - err = conn.CloseWithoutFlush() - if err != nil { - wn.log.Infof("tryConnect: failed to CloseWithoutFlush to connection for %s", conn.RemoteAddr().String()) + err2 = conn.CloseWithoutFlush() + if err2 != nil { + wn.log.Infof("tryConnect: failed to CloseWithoutFlush to connection for %s: %v", conn.RemoteAddr().String(), err2) } } diff --git a/shared/pingpong/accounts.go b/shared/pingpong/accounts.go index ea9d74cc07..0471d84be4 100644 --- a/shared/pingpong/accounts.go +++ b/shared/pingpong/accounts.go @@ -197,9 +197,9 @@ func (pps *WorkerState) ensureAccounts(ac *libgoal.Client) (err error) { srcAcctPresent = true } - ai, err := ac.AccountInformation(addr, true) - if err != nil { - return err + ai, aiErr := ac.AccountInformation(addr, true) + if aiErr != nil { + return aiErr } amt := ai.Amount diff --git a/stateproof/builder.go b/stateproof/builder.go index 28d5d2b47f..7d90e8b731 100644 --- a/stateproof/builder.go +++ b/stateproof/builder.go @@ -270,9 +270,9 @@ func (spw *Worker) getAllOnlineProverRounds() ([]basics.Round, error) { var rnds []basics.Round err = spw.db.Atomic(func(_ context.Context, tx *sql.Tx) error { - var err error - rnds, err = getSignatureRounds(tx, threshold, latestStateProofRound) - return err + var err2 error + rnds, err2 = getSignatureRounds(tx, threshold, latestStateProofRound) + return err2 }) return rnds, err diff --git a/tools/debug/dumpblocks/main.go b/tools/debug/dumpblocks/main.go index 461e7949cf..7327b4f55e 100644 --- a/tools/debug/dumpblocks/main.go +++ b/tools/debug/dumpblocks/main.go @@ -87,7 +87,7 @@ func main() { } } if minRound == 0 { - err := db.QueryRow("SELECT MIN(rnd) FROM blocks").Scan(&minRound) + err = db.QueryRow("SELECT MIN(rnd) FROM blocks").Scan(&minRound) if err != nil { panic(err) } diff --git a/util/execpool/stream.go b/util/execpool/stream.go index af2bb08091..1ac61cb273 100644 --- a/util/execpool/stream.go +++ b/util/execpool/stream.go @@ -112,8 +112,8 @@ func (sv *StreamToBatch) batchingLoop() { // if no batchable items here, send this as a task of its own if numberOfBatchable == 0 { - err := sv.addBatchToThePoolNow([]InputJob{job}) - if err != nil { + addErr := sv.addBatchToThePoolNow([]InputJob{job}) + if addErr != nil { return } continue // job is handled, continue @@ -129,8 +129,8 @@ func (sv *StreamToBatch) batchingLoop() { // do not consider adding more jobs to this batch. // bypass the exec pool situation and queue anyway // this is to prevent creation of very large batches - err := sv.addBatchToThePoolNow(uJobs) - if err != nil { + addErr := sv.addBatchToThePoolNow(uJobs) + if addErr != nil { return } added = true