chore: fix lint issues in the node repo

.github/workflows/e2e.yml

@@ -37,7 +37,7 @@ jobs:
       DOCKER_IMAGE: ghcr.io/${{ github.repository_owner }}/zetanode
       DOCKER_TAG: ${{ github.ref == 'refs/heads/develop' && 'develop' || github.sha }}
     outputs:
-      image: ${{ fromJson(steps.build.outputs.metadata)['image.name'] }}
+      image: ${{ steps.build.outputs.metadata && fromJson(steps.build.outputs.metadata)['image.name'] || '' }}
     steps:
       - uses: actions/checkout@v4
 

.golangci.yml

@@ -94,3 +94,13 @@ linters:
 
       - linters: [staticcheck]
         text: "QF1008"
+
+      # Packages with names that conflict with Go stdlib
+      - linters: [revive]
+        path: "(pkg/(crypto|errors|math|os)|cmd/zetatool/context|zetaclient/context|rpc/namespaces/ethereum/net)/"
+        text: "var-naming"
+
+      # Packages with generic names (types, common, interfaces, utils, base)
+      - linters: [revive]
+        path: "/(types|common|interfaces|utils|base)/"
+        text: "var-naming"

app/app.go

@@ -153,7 +153,7 @@ var (
 )
 
 func getGovProposalHandlers() []govclient.ProposalHandler {
-	var govProposalHandlers []govclient.ProposalHandler
+	govProposalHandlers := make([]govclient.ProposalHandler, 0, 1)
 	govProposalHandlers = append(govProposalHandlers,
 		paramsclient.ProposalHandler,
 		//ibcclientclient.UpdateClientProposalHandler,

cmd/zetacore_utils/main.go

@@ -97,7 +97,8 @@ func main() {
 		}
 	}
 
-	args := []string{"tx", "bank", "multi-send", signer}
+	args := make([]string, 0, 17+len(addresses))
+	args = append(args, "tx", "bank", "multi-send", signer)
 	args = append(args, addresses...)
 	args = append(
 		args,

cmd/zetatool/cctx/cctx_details.go

@@ -107,7 +107,7 @@ func (c *TrackingDetails) UpdateHashListAndPendingStatus(ctx *context.Context) {
 	tracker, err := zetacoreClient.GetOutboundTracker(goCtx, outboundChain.ChainId, outboundNonce)
 	if err == nil && tracker != nil {
 		c.updateOutboundConfirmation()
-		var hashList []string
+		hashList := make([]string, 0, len(tracker.HashList))
 		for _, hash := range tracker.HashList {
 			hashList = append(hashList, hash.TxHash)
 		}

cmd/zetatool/cli/tss_balances.go

@@ -159,7 +159,9 @@ func getTSSBalances(cmd *cobra.Command, args []string) error {
 		}
 		fmt.Printf("=== TSS %d of %d ===\n", i+1, len(tssHistoryRes.TssList))
 
-		if err := printTSSBalances(ctx, cfg, tss, network, zetacoreClient.Observer, showMigrationAmounts, showNonces); err != nil {
+		if err := printTSSBalances(
+			ctx, cfg, tss, network, zetacoreClient.Observer, showMigrationAmounts, showNonces,
+		); err != nil {
 			fmt.Printf("Error fetching balances for TSS (height %d): %v\n", tss.FinalizedZetaHeight, err)
 			continue
 		}
@@ -637,7 +639,9 @@ func printTSSBalances(
 		} else {
 			for i := range balances {
 				if balances[i].ChainID != 0 {
-					nonceLow, nonceHigh, ok := getPendingNoncesForChainAndTss(allNonces, balances[i].ChainID, tss.TssPubkey)
+					nonceLow, nonceHigh, ok := getPendingNoncesForChainAndTss(
+						allNonces, balances[i].ChainID, tss.TssPubkey,
+					)
 					if ok {
 						balances[i].PendingNonceLow = nonceLow
 						balances[i].PendingNonceHigh = nonceHigh

e2e/e2etests/test_crosschain_swap.go

@@ -83,7 +83,7 @@ func setupCrosschainSwap(r *runner.E2ERunner) {
 func testERC20ToBTC(r *runner.E2ERunner) {
 	// msg would be [ZEVMSwapAppAddr, memobytes]
 	// memobytes is dApp specific; see the contracts/ZEVMSwapApp.sol for details
-	msg := []byte{}
+	msg := make([]byte, 0, len(r.ZEVMSwapAppAddr.Bytes()))
 	msg = append(msg, r.ZEVMSwapAppAddr.Bytes()...)
 	memobytes, err := r.ZEVMSwapApp.EncodeMemo(
 		&bind.CallOpts{},

e2e/e2etests/test_solana_withdraw_and_call_alt.go

@@ -63,16 +63,16 @@ func TestSolanaWithdrawAndCallAddressLookupTable(r *runner.E2ERunner, args []str
 	// in case AddressLookupTable address is not provided (eg. for local testing) use prefunded random accounts to create AddressLookupTable
 	randomWallets := []solana.PublicKey{}
 	if initAddressLookupTable {
-		accounts := []solana.PublicKey{}
+		accounts := make([]solana.PublicKey, 0, 4)
 
 		accounts = append(accounts, connectedPda)
 		accounts = append(accounts, r.ComputePdaAddress())
 		accounts = append(accounts, solana.SystemProgramID)
 		accounts = append(accounts, solana.SysVarInstructionsPubkey)
 		predefinedAccountsLen := len(accounts)
-		writableIndexes = []uint8{0} // only first one is mutable
-
 		addressLookupTableAddress, randomWallets = r.SetupTestAddressLookupTableWithRandomWallets(accounts)
+		writableIndexes = make([]uint8, 0, 1+len(randomWallets))
+		writableIndexes = append(writableIndexes, 0) // only first one is mutable
 
 		// based on example accounts from above, all random wallets are writable
 		// since they will get some lamports from connected program example
@@ -95,7 +95,7 @@ func TestSolanaWithdrawAndCallAddressLookupTable(r *runner.E2ERunner, args []str
 	encoded, err := msg.Encode()
 	require.NoError(r, err)
 
-	randomWalletsBalanceBefore := []uint64{}
+	randomWalletsBalanceBefore := make([]uint64, 0, len(randomWallets))
 	for _, acc := range randomWallets {
 		balanceBefore, err := r.SolanaClient.GetAccountInfo(r.Ctx, acc)
 		require.NoError(r, err)

e2e/e2etests/test_spl_withdraw_and_call_alt.go

@@ -73,7 +73,7 @@ func TestSPLWithdrawAndCallAddressLookupTable(r *runner.E2ERunner, args []string
 	// in case AddressLookupTable address is not provided (eg. for local testing) use prefunded random accounts to create AddressLookupTable
 	randomWallets := []solana.PublicKey{}
 	if initAddressLookupTable {
-		accounts := []solana.PublicKey{}
+		accounts := make([]solana.PublicKey, 0, 6)
 
 		accounts = append(accounts, connectedPda)
 		accounts = append(accounts, connectedPdaAta)
@@ -82,9 +82,9 @@ func TestSPLWithdrawAndCallAddressLookupTable(r *runner.E2ERunner, args []string
 		accounts = append(accounts, solana.TokenProgramID)
 		accounts = append(accounts, solana.SystemProgramID)
 		predefinedAccountsLen := len(accounts)
-		writableIndexes = []uint8{0, 1} // only first 2 are mutable
-
 		addressLookupTableAddress, randomWallets = r.SetupTestAddressLookupTableWithRandomWalletsSPL(accounts)
+		writableIndexes = make([]uint8, 0, 2+len(randomWallets))
+		writableIndexes = append(writableIndexes, 0, 1) // only first 2 are mutable
 
 		// based on example accounts from above, all random wallets are writable
 		// since they will get some SPL from connected program example
@@ -108,7 +108,7 @@ func TestSPLWithdrawAndCallAddressLookupTable(r *runner.E2ERunner, args []string
 	require.NoError(r, err)
 
 	// get receivers ata balances before withdraw
-	randomWalletsBalanceBefore := []*big.Int{}
+	randomWalletsBalanceBefore := make([]*big.Int, 0, len(randomWallets))
 	for _, acc := range randomWallets {
 		receiverBalanceBefore, err := r.SolanaClient.GetTokenAccountBalance(r.Ctx, acc, rpc.CommitmentConfirmed)
 		require.NoError(r, err)

e2e/runner/e2etest.go

@@ -120,7 +120,7 @@ type E2ETestRunConfig struct {
 
 // GetE2ETestsToRunByName prepares a list of E2ETests to run based on given test names without arguments
 func (r *E2ERunner) GetE2ETestsToRunByName(availableTests []E2ETest, testNames ...string) ([]E2ETest, error) {
-	tests := []E2ETestRunConfig{}
+	tests := make([]E2ETestRunConfig, 0, len(testNames))
 	for _, testName := range testNames {
 		tests = append(tests, E2ETestRunConfig{
 			Name: testName,

e2e/runner/setup_bitcoin.go

@@ -93,7 +93,7 @@ func (r *E2ERunner) SetupBtcAddress(createWallet bool) {
 			false,  // descriptors
 			true,   // load_on_startup
 		}
-		argsRawMsg := []json.RawMessage{}
+		argsRawMsg := make([]json.RawMessage, 0, len(args))
 		for _, arg := range args {
 			encodedArg, err := json.Marshal(arg)
 			require.NoError(r, err)

e2e/runner/setup_solana.go

@@ -46,7 +46,7 @@ func (r *E2ERunner) SetupSolana(gatewayID, deployerPrivateKey, splAccountPrivate
 
 	// create 'initialize' instruction
 	var inst solana.GenericInstruction
-	accountSlice := []*solana.AccountMeta{}
+	accountSlice := make([]*solana.AccountMeta, 0, 3)
 	accountSlice = append(accountSlice, solana.Meta(privkey.PublicKey()).WRITE().SIGNER())
 	accountSlice = append(accountSlice, solana.Meta(pdaComputed).WRITE())
 	accountSlice = append(accountSlice, solana.Meta(solana.SystemProgramID))
@@ -76,7 +76,7 @@ func (r *E2ERunner) SetupSolana(gatewayID, deployerPrivateKey, splAccountPrivate
 	require.NoError(r, err)
 
 	var instConnected solana.GenericInstruction
-	accountSliceConnected := []*solana.AccountMeta{}
+	accountSliceConnected := make([]*solana.AccountMeta, 0, 3)
 	accountSliceConnected = append(accountSliceConnected, solana.Meta(privkey.PublicKey()).WRITE().SIGNER())
 	accountSliceConnected = append(accountSliceConnected, solana.Meta(connectedPda).WRITE())
 	accountSliceConnected = append(accountSliceConnected, solana.Meta(solana.SystemProgramID))
@@ -106,7 +106,7 @@ func (r *E2ERunner) SetupSolana(gatewayID, deployerPrivateKey, splAccountPrivate
 	require.NoError(r, err)
 
 	var instConnectedSPL solana.GenericInstruction
-	accountSliceConnectedSPL := []*solana.AccountMeta{}
+	accountSliceConnectedSPL := make([]*solana.AccountMeta, 0, 3)
 	accountSliceConnectedSPL = append(accountSliceConnectedSPL, solana.Meta(privkey.PublicKey()).WRITE().SIGNER())
 	accountSliceConnectedSPL = append(accountSliceConnectedSPL, solana.Meta(connectedSPLPda).WRITE())
 	accountSliceConnectedSPL = append(accountSliceConnectedSPL, solana.Meta(solana.SystemProgramID))
@@ -248,7 +248,7 @@ func (r *E2ERunner) UpdateTSSAddressSolana(gatewayID, deployerPrivateKey string)
 
 	// create 'initialize' instruction
 	var inst solana.GenericInstruction
-	accountSlice := []*solana.AccountMeta{}
+	accountSlice := make([]*solana.AccountMeta, 0, 3)
 	accountSlice = append(accountSlice, solana.Meta(privkey.PublicKey()).WRITE().SIGNER())
 	accountSlice = append(accountSlice, solana.Meta(pdaComputed).WRITE())
 	accountSlice = append(accountSlice, solana.Meta(solana.SystemProgramID))

e2e/runner/solana.go

@@ -958,7 +958,7 @@ func (r *E2ERunner) SetupTestAddressLookupTableWithRandomWalletsSPL(
 		randomWallets[i] = solana.MustPublicKeyFromBase58(prefundedRandomWalletAddresses[i])
 	}
 
-	randomWalletsAta := []solana.PublicKey{}
+	randomWalletsAta := make([]solana.PublicKey, 0, len(randomWallets))
 	for _, acc := range randomWallets {
 		ata := r.ResolveSolanaATA(r.GetSolanaPrivKey(), acc, r.SPLAddr)
 		randomWalletsAta = append(randomWalletsAta, ata)

e2e/runner/solana_gateway_upgrade.go

@@ -70,7 +70,7 @@ func (r *E2ERunner) VerifyUpgradedInstruction(deployerPrivateKey string) {
 	data := append(discriminator, []byte{}...)
 
 	var instConnected solana.GenericInstruction
-	var accountSliceConnected []*solana.AccountMeta
+	accountSliceConnected := make([]*solana.AccountMeta, 0, 1)
 	accountSliceConnected = append(accountSliceConnected, solana.Meta(privkey.PublicKey()).WRITE().SIGNER())
 	instConnected.ProgID = r.GatewayProgram
 	instConnected.AccountValues = accountSliceConnected

e2e/utils/zetacore.go

@@ -258,7 +258,7 @@ func WaitOutboundTracker(
 				logger.Info("  Nonce: %d\n", tracker.Nonce)
 				logger.Info("  HashList:\n")
 
-				hashes := []string{}
+				hashes := make([]string, 0, len(tracker.HashList))
 				for j, hash := range tracker.HashList {
 					hashes = append(hashes, hash.TxHash)
 					logger.Info("    hash[%d]: %s\n", j, hash.TxHash)

pkg/contracts/solana/gateway_message.go

@@ -83,8 +83,8 @@ func (msg *MsgWithdraw) To() solana.PublicKey {
 
 // Hash packs the withdraw message and computes the hash
 func (msg *MsgWithdraw) Hash() [32]byte {
-	var message []byte
 	buff := make([]byte, 8)
+	message := make([]byte, 0, len(InstructionIdentifier)+1+3*len(buff)+len(msg.to))
 
 	message = append(message, InstructionIdentifier...)
 	message = append(message, InstructionWithdraw)
@@ -188,8 +188,8 @@ func (msg *MsgIncrementNonce) Amount() uint64 {
 
 // Hash packs the increment_nonce message and computes the hash
 func (msg *MsgIncrementNonce) Hash() [32]byte {
-	var message []byte
 	buff := make([]byte, 8)
+	message := make([]byte, 0, len(InstructionIdentifier)+1+3*len(buff))
 
 	message = append(message, InstructionIdentifier...)
 	message = append(message, InstructionIncrementNonce)
@@ -496,8 +496,8 @@ func (msg *MsgWithdrawSPL) Decimals() uint8 {
 
 // Hash packs the withdraw spl message and computes the hash
 func (msg *MsgWithdrawSPL) Hash() [32]byte {
-	var message []byte
 	buff := make([]byte, 8)
+	message := make([]byte, 0, len(InstructionIdentifier)+1+3*len(buff)+len(msg.mintAccount)+len(msg.recipientAta)+1)
 
 	message = append(message, InstructionIdentifier...)
 	message = append(message, InstructionWithdrawSplToken)
@@ -812,8 +812,12 @@ func (msg *MsgWhitelist) Nonce() uint64 {
 
 // Hash packs the whitelist message and computes the hash
 func (msg *MsgWhitelist) Hash() [32]byte {
-	var message []byte
 	buff := make([]byte, 8)
+	message := make(
+		[]byte,
+		0,
+		len(InstructionIdentifier)+1+2*len(buff)+len(msg.whitelistCandidate)+len(msg.whitelistEntry),
+	)
 
 	message = append(message, InstructionIdentifier...)
 	message = append(message, InstructionWhitelistSplToken)

pkg/proofs/bitcoin/bitcoin_spv.go

@@ -34,7 +34,7 @@ func Prove(txid Hash256Digest, merkleRoot Hash256Digest, intermediateNodes []byt
 		return true
 	}
 
-	proof := []byte{}
+	proof := make([]byte, 0, len(txid)+len(intermediateNodes)+len(merkleRoot))
 	proof = append(proof, txid[:]...)
 	proof = append(proof, intermediateNodes...)
 	proof = append(proof, merkleRoot[:]...)
@@ -51,7 +51,7 @@ func Hash256(in []byte) Hash256Digest {
 
 // Hash256MerkleStep concatenates and hashes two inputs for merkle proving
 func Hash256MerkleStep(a []byte, b []byte) Hash256Digest {
-	c := []byte{}
+	c := make([]byte, 0, len(a)+len(b))
 	c = append(c, a...)
 	c = append(c, b...)
 	return Hash256(c)

simulation/state.go

@@ -195,13 +195,13 @@ func extractObserverGenesisState(
 	tss.OperatorAddressList = observers
 
 	// Create a tss history
-	tssHistory := make([]observertypes.TSS, 0)
+	tssHistory := make([]observertypes.TSS, 0, 1)
 	tssHistory = append(tssHistory, tss)
 
 	// Create chainnonces and pendingnonces
 	chains := zetachains.DefaultChainsList()
-	chainsNonces := make([]observertypes.ChainNonces, 0)
-	pendingNonces := make([]observertypes.PendingNonces, 0)
+	chainsNonces := make([]observertypes.ChainNonces, 0, len(chains))
+	pendingNonces := make([]observertypes.PendingNonces, 0, len(chains))
 	for _, chain := range chains {
 		chainNonce := observertypes.ChainNonces{
 			ChainId: chain.ChainId,
@@ -348,8 +348,8 @@ func extractFungibleGenesisState(
 		Gateway:        sample.EthAddressFromRand(r).String(),
 	}
 
-	foreignCoins := make([]fungibletypes.ForeignCoins, 0)
 	chains := zetachains.DefaultChainsList()
+	foreignCoins := make([]fungibletypes.ForeignCoins, 0, len(chains))
 
 	for _, chain := range chains {
 		foreignCoin := fungibletypes.ForeignCoins{

x/crosschain/keeper/foreign_coins.go

@@ -8,7 +8,7 @@ import (
 
 func (k Keeper) GetAllForeignCoins(ctx sdk.Context) []fungibleModuleTypes.ForeignCoins {
 	chains := k.zetaObserverKeeper.GetSupportedChains(ctx)
-	var fCoins []fungibleModuleTypes.ForeignCoins
+	fCoins := make([]fungibleModuleTypes.ForeignCoins, 0, len(chains))
 	for _, chain := range chains {
 		fCoins = append(fCoins, k.fungibleKeeper.GetAllForeignCoinsForChain(ctx, chain.ChainId)...)
 	}

x/crosschain/types/key_inbound_hash_to_cctx.go

@@ -10,9 +10,8 @@ const (
 func InboundHashToCctxKey(
 	inboundHash string,
 ) []byte {
-	var key []byte
-
 	inboundHashBytes := []byte(inboundHash)
+	key := make([]byte, 0, len(inboundHashBytes)+1)
 	key = append(key, inboundHashBytes...)
 	key = append(key, []byte("/")...)
 

x/crosschain/types/keys.go

@@ -68,9 +68,8 @@ const (
 func OutboundTrackerKey(
 	index string,
 ) []byte {
-	var key []byte
-
 	indexBytes := []byte(index)
+	key := make([]byte, 0, len(indexBytes)+1)
 	key = append(key, indexBytes...)
 	key = append(key, []byte("/")...)
 

x/fungible/types/key_foreign_coins.go

@@ -9,9 +9,8 @@ const (
 func ForeignCoinsKey(
 	index string,
 ) []byte {
-	var key []byte
-
 	indexBytes := []byte(index)
+	key := make([]byte, 0, len(indexBytes)+1)
 	key = append(key, indexBytes...)
 	key = append(key, []byte("/")...)
 

zetaclient/config/config.go

@@ -104,7 +104,7 @@ func GetRestrictedAddresses() []string {
 	restrictedAddressBookLock.RLock()
 	defer restrictedAddressBookLock.RUnlock()
 
-	addresses := []string{}
+	addresses := make([]string, 0, len(restrictedAddressBook))
 	for addr := range restrictedAddressBook {
 		addresses = append(addresses, addr)
 	}