fix: gofmt -s across repo (CI format check)

accounts/abi/bind/v2/dep_tree_test.go

@@ -292,7 +292,7 @@ func TestContractLinking(t *testing.T) {
 			},
 		},
 		// test two contracts can be deployed which don't share deps
-		linkTestCaseInput{
+		{
 			map[rune][]rune{
 				'a': {'b', 'c', 'd', 'e'},
 				'f': {'g', 'h', 'i', 'j'}},
@@ -302,7 +302,7 @@ func TestContractLinking(t *testing.T) {
 			},
 		},
 		// test two contracts can be deployed which share deps
-		linkTestCaseInput{
+		{
 			map[rune][]rune{
 				'a': {'b', 'c', 'd', 'e'},
 				'f': {'g', 'c', 'd', 'h'}},
@@ -312,7 +312,7 @@ func TestContractLinking(t *testing.T) {
 			},
 		},
 		// test one contract with overrides for all lib deps
-		linkTestCaseInput{
+		{
 			map[rune][]rune{
 				'a': {'b', 'c', 'd', 'e'}},
 			map[rune]struct{}{'b': {}, 'c': {}, 'd': {}, 'e': {}},
@@ -320,7 +320,7 @@ func TestContractLinking(t *testing.T) {
 				'a': {}},
 		},
 		// test one contract with overrides for some lib deps
-		linkTestCaseInput{
+		{
 			map[rune][]rune{
 				'a': {'b', 'c'}},
 			map[rune]struct{}{'b': {}, 'c': {}},
@@ -328,7 +328,7 @@ func TestContractLinking(t *testing.T) {
 				'a': {}},
 		},
 		// test deployment of a contract with overrides
-		linkTestCaseInput{
+		{
 			map[rune][]rune{
 				'a': {}},
 			map[rune]struct{}{'a': {}},
@@ -336,7 +336,7 @@ func TestContractLinking(t *testing.T) {
 		},
 		// two contracts ('a' and 'f') share some dependencies.  contract 'a' is marked as an override.  expect that any of
 		// its depdencies that aren't shared with 'f' are not deployed.
-		linkTestCaseInput{map[rune][]rune{
+		{map[rune][]rune{
 			'a': {'b', 'c', 'd', 'e'},
 			'f': {'g', 'c', 'd', 'h'}},
 			map[rune]struct{}{'a': {}},

core/rawdb/zap_ancient.go

@@ -40,9 +40,9 @@ import (
 	"sync"
 	"sync/atomic"
 
+	"github.com/golang/snappy"
 	"github.com/luxfi/geth/ethdb"
 	log "github.com/luxfi/log"
-	"github.com/golang/snappy"
 )
 
 // kindByte assigns a stable single-byte marker per table name.

internal/ethapi/api_test.go

@@ -1008,7 +1008,7 @@ func TestCall(t *testing.T) {
 					Balance: big.NewInt(params.Ether),
 					Nonce:   1,
 					Storage: map[common.Hash]common.Hash{
-						common.Hash{}: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"),
+						{}: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"),
 					},
 				},
 			},
@@ -3785,7 +3785,7 @@ func TestCreateAccessListWithStateOverrides(t *testing.T) {
 				Balance: (*hexutil.Big)(big.NewInt(1000000000000000000)),
 				Nonce:   &nonce,
 				State: map[common.Hash]common.Hash{
-					common.Hash{}: common.HexToHash("0x000000000000000000000000000000000000000000000000000000000000002a"),
+					{}: common.HexToHash("0x000000000000000000000000000000000000000000000000000000000000002a"),
 				},
 			},
 		}

trie/proof_test.go

@@ -1011,7 +1011,7 @@ func TestRangeProofErrors(t *testing.T) {
 	}
 	// Non-increasing paths
 	_, err = VerifyRangeProof((common.Hash{}), []byte{},
-		[][]byte{[]byte{2, 1}, []byte{2, 1}}, make([][]byte, 2), nil)
+		[][]byte{{2, 1}, {2, 1}}, make([][]byte, 2), nil)
 	if have, want := err.Error(), "range is not monotonically increasing"; have != want {
 		t.Fatalf("wrong error, have %q, want %q", err.Error(), want)
 	}
@@ -1019,15 +1019,15 @@ func TestRangeProofErrors(t *testing.T) {
 	// require rewriting/overwriting the previous value-node, thus can only
 	// happen if the data is corrupt.
 	_, err = VerifyRangeProof((common.Hash{}), []byte{},
-		[][]byte{[]byte{2, 1}, []byte{2, 1, 2}},
-		[][]byte{[]byte{1}, []byte{1}}, nil)
+		[][]byte{{2, 1}, {2, 1, 2}},
+		[][]byte{{1}, {1}}, nil)
 	if have, want := err.Error(), "range contains path prefixes"; have != want {
 		t.Fatalf("wrong error, have %q, want %q", err.Error(), want)
 	}
 	// Empty values (deletions)
 	_, err = VerifyRangeProof((common.Hash{}), []byte{},
-		[][]byte{[]byte{2, 1}, []byte{2, 2}},
-		[][]byte{[]byte{1}, []byte{}}, nil)
+		[][]byte{{2, 1}, {2, 2}},
+		[][]byte{{1}, {}}, nil)
 	if have, want := err.Error(), "range contains deletion"; have != want {
 		t.Fatalf("wrong error, have %q, want %q", err.Error(), want)
 	}

triedb/pathdb/layertree_test.go

@@ -55,9 +55,9 @@ func TestLayerCap(t *testing.T) {
 			layers: 2,
 			base:   common.Hash{0x2},
 			snapshot: map[common.Hash]struct{}{
-				common.Hash{0x2}: {},
-				common.Hash{0x3}: {},
-				common.Hash{0x4}: {},
+				{0x2}: {},
+				{0x3}: {},
+				{0x4}: {},
 			},
 		},
 		{
@@ -76,8 +76,8 @@ func TestLayerCap(t *testing.T) {
 			layers: 1,
 			base:   common.Hash{0x3},
 			snapshot: map[common.Hash]struct{}{
-				common.Hash{0x3}: {},
-				common.Hash{0x4}: {},
+				{0x3}: {},
+				{0x4}: {},
 			},
 		},
 		{
@@ -96,7 +96,7 @@ func TestLayerCap(t *testing.T) {
 			layers: 0,
 			base:   common.Hash{0x4},
 			snapshot: map[common.Hash]struct{}{
-				common.Hash{0x4}: {},
+				{0x4}: {},
 			},
 		},
 		{
@@ -119,9 +119,9 @@ func TestLayerCap(t *testing.T) {
 			layers: 2,
 			base:   common.Hash{0x2a},
 			snapshot: map[common.Hash]struct{}{
-				common.Hash{0x4a}: {},
-				common.Hash{0x3a}: {},
-				common.Hash{0x2a}: {},
+				{0x4a}: {},
+				{0x3a}: {},
+				{0x2a}: {},
 			},
 		},
 		{
@@ -144,8 +144,8 @@ func TestLayerCap(t *testing.T) {
 			layers: 1,
 			base:   common.Hash{0x3a},
 			snapshot: map[common.Hash]struct{}{
-				common.Hash{0x4a}: {},
-				common.Hash{0x3a}: {},
+				{0x4a}: {},
+				{0x3a}: {},
 			},
 		},
 		{
@@ -168,11 +168,11 @@ func TestLayerCap(t *testing.T) {
 			layers: 2,
 			base:   common.Hash{0x2},
 			snapshot: map[common.Hash]struct{}{
-				common.Hash{0x4a}: {},
-				common.Hash{0x3a}: {},
-				common.Hash{0x4b}: {},
-				common.Hash{0x3b}: {},
-				common.Hash{0x2}:  {},
+				{0x4a}: {},
+				{0x3a}: {},
+				{0x4b}: {},
+				{0x3b}: {},
+				{0x2}:  {},
 			},
 		},
 	}
@@ -261,7 +261,7 @@ func TestDescendant(t *testing.T) {
 				return tr
 			},
 			snapshotA: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x1}: {
+				{0x1}: {
 					common.Hash{0x2}: {},
 				},
 			},
@@ -271,11 +271,11 @@ func TestDescendant(t *testing.T) {
 				tr.add(common.Hash{0x3}, common.Hash{0x2}, 2, NewNodeSetWithOrigin(nil, nil), NewStateSetWithOrigin(nil, nil, nil, nil, false))
 			},
 			snapshotB: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x1}: {
+				{0x1}: {
 					common.Hash{0x2}: {},
 					common.Hash{0x3}: {},
 				},
-				common.Hash{0x2}: {
+				{0x2}: {
 					common.Hash{0x3}: {},
 				},
 			},
@@ -291,16 +291,16 @@ func TestDescendant(t *testing.T) {
 				return tr
 			},
 			snapshotA: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x1}: {
+				{0x1}: {
 					common.Hash{0x2}: {},
 					common.Hash{0x3}: {},
 					common.Hash{0x4}: {},
 				},
-				common.Hash{0x2}: {
+				{0x2}: {
 					common.Hash{0x3}: {},
 					common.Hash{0x4}: {},
 				},
-				common.Hash{0x3}: {
+				{0x3}: {
 					common.Hash{0x4}: {},
 				},
 			},
@@ -310,11 +310,11 @@ func TestDescendant(t *testing.T) {
 				tr.cap(common.Hash{0x4}, 2)
 			},
 			snapshotB: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x2}: {
+				{0x2}: {
 					common.Hash{0x3}: {},
 					common.Hash{0x4}: {},
 				},
-				common.Hash{0x3}: {
+				{0x3}: {
 					common.Hash{0x4}: {},
 				},
 			},
@@ -330,16 +330,16 @@ func TestDescendant(t *testing.T) {
 				return tr
 			},
 			snapshotA: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x1}: {
+				{0x1}: {
 					common.Hash{0x2}: {},
 					common.Hash{0x3}: {},
 					common.Hash{0x4}: {},
 				},
-				common.Hash{0x2}: {
+				{0x2}: {
 					common.Hash{0x3}: {},
 					common.Hash{0x4}: {},
 				},
-				common.Hash{0x3}: {
+				{0x3}: {
 					common.Hash{0x4}: {},
 				},
 			},
@@ -349,7 +349,7 @@ func TestDescendant(t *testing.T) {
 				tr.cap(common.Hash{0x4}, 1)
 			},
 			snapshotB: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x3}: {
+				{0x3}: {
 					common.Hash{0x4}: {},
 				},
 			},
@@ -365,16 +365,16 @@ func TestDescendant(t *testing.T) {
 				return tr
 			},
 			snapshotA: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x1}: {
+				{0x1}: {
 					common.Hash{0x2}: {},
 					common.Hash{0x3}: {},
 					common.Hash{0x4}: {},
 				},
-				common.Hash{0x2}: {
+				{0x2}: {
 					common.Hash{0x3}: {},
 					common.Hash{0x4}: {},
 				},
-				common.Hash{0x3}: {
+				{0x3}: {
 					common.Hash{0x4}: {},
 				},
 			},
@@ -400,7 +400,7 @@ func TestDescendant(t *testing.T) {
 				return tr
 			},
 			snapshotA: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x1}: {
+				{0x1}: {
 					common.Hash{0x2a}: {},
 					common.Hash{0x3a}: {},
 					common.Hash{0x4a}: {},
@@ -408,18 +408,18 @@ func TestDescendant(t *testing.T) {
 					common.Hash{0x3b}: {},
 					common.Hash{0x4b}: {},
 				},
-				common.Hash{0x2a}: {
+				{0x2a}: {
 					common.Hash{0x3a}: {},
 					common.Hash{0x4a}: {},
 				},
-				common.Hash{0x3a}: {
+				{0x3a}: {
 					common.Hash{0x4a}: {},
 				},
-				common.Hash{0x2b}: {
+				{0x2b}: {
 					common.Hash{0x3b}: {},
 					common.Hash{0x4b}: {},
 				},
-				common.Hash{0x3b}: {
+				{0x3b}: {
 					common.Hash{0x4b}: {},
 				},
 			},
@@ -429,11 +429,11 @@ func TestDescendant(t *testing.T) {
 				tr.cap(common.Hash{0x4a}, 2)
 			},
 			snapshotB: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x2a}: {
+				{0x2a}: {
 					common.Hash{0x3a}: {},
 					common.Hash{0x4a}: {},
 				},
-				common.Hash{0x3a}: {
+				{0x3a}: {
 					common.Hash{0x4a}: {},
 				},
 			},
@@ -453,7 +453,7 @@ func TestDescendant(t *testing.T) {
 				return tr
 			},
 			snapshotA: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x1}: {
+				{0x1}: {
 					common.Hash{0x2a}: {},
 					common.Hash{0x3a}: {},
 					common.Hash{0x4a}: {},
@@ -461,18 +461,18 @@ func TestDescendant(t *testing.T) {
 					common.Hash{0x3b}: {},
 					common.Hash{0x4b}: {},
 				},
-				common.Hash{0x2a}: {
+				{0x2a}: {
 					common.Hash{0x3a}: {},
 					common.Hash{0x4a}: {},
 				},
-				common.Hash{0x3a}: {
+				{0x3a}: {
 					common.Hash{0x4a}: {},
 				},
-				common.Hash{0x2b}: {
+				{0x2b}: {
 					common.Hash{0x3b}: {},
 					common.Hash{0x4b}: {},
 				},
-				common.Hash{0x3b}: {
+				{0x3b}: {
 					common.Hash{0x4b}: {},
 				},
 			},
@@ -482,7 +482,7 @@ func TestDescendant(t *testing.T) {
 				tr.cap(common.Hash{0x4a}, 1)
 			},
 			snapshotB: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x3a}: {
+				{0x3a}: {
 					common.Hash{0x4a}: {},
 				},
 			},
@@ -501,23 +501,23 @@ func TestDescendant(t *testing.T) {
 				return tr
 			},
 			snapshotA: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x1}: {
+				{0x1}: {
 					common.Hash{0x2}:  {},
 					common.Hash{0x3a}: {},
 					common.Hash{0x4a}: {},
 					common.Hash{0x3b}: {},
 					common.Hash{0x4b}: {},
 				},
-				common.Hash{0x2}: {
+				{0x2}: {
 					common.Hash{0x3a}: {},
 					common.Hash{0x4a}: {},
 					common.Hash{0x3b}: {},
 					common.Hash{0x4b}: {},
 				},
-				common.Hash{0x3a}: {
+				{0x3a}: {
 					common.Hash{0x4a}: {},
 				},
-				common.Hash{0x3b}: {
+				{0x3b}: {
 					common.Hash{0x4b}: {},
 				},
 			},
@@ -528,16 +528,16 @@ func TestDescendant(t *testing.T) {
 				tr.cap(common.Hash{0x4a}, 2)
 			},
 			snapshotB: map[common.Hash]map[common.Hash]struct{}{
-				common.Hash{0x2}: {
+				{0x2}: {
 					common.Hash{0x3a}: {},
 					common.Hash{0x4a}: {},
 					common.Hash{0x3b}: {},
 					common.Hash{0x4b}: {},
 				},
-				common.Hash{0x3a}: {
+				{0x3a}: {
 					common.Hash{0x4a}: {},
 				},
-				common.Hash{0x3b}: {
+				{0x3b}: {
 					common.Hash{0x4b}: {},
 				},
 			},