chore: make format golines (#637)

Signed-off-by: Chris Gianelloni <[email protected]>

Author: wolf31o2

cbor/tags.go

@@ -42,7 +42,10 @@ var customTagSet _cbor.TagSet
 func init() {
 	// Build custom tagset
 	customTagSet = _cbor.NewTagSet()
-	tagOpts := _cbor.TagOptions{EncTag: _cbor.EncTagRequired, DecTag: _cbor.DecTagRequired}
+	tagOpts := _cbor.TagOptions{
+		EncTag: _cbor.EncTagRequired,
+		DecTag: _cbor.DecTagRequired,
+	}
 	// Wrapped CBOR
 	if err := customTagSet.Add(
 		tagOpts,

cbor/value.go

@@ -290,7 +290,8 @@ func (c *Constructor) UnmarshalCBOR(data []byte) error {
 	if _, err := Decode(tmpTag.Content, &tmpValue); err != nil {
 		return err
 	}
-	if tmpTag.Number >= CborTagAlternative1Min && tmpTag.Number <= CborTagAlternative1Max {
+	if tmpTag.Number >= CborTagAlternative1Min &&
+		tmpTag.Number <= CborTagAlternative1Max {
 		// Alternatives 0-6
 		c.constructor = uint(tmpTag.Number - CborTagAlternative1Min)
 		c.value = &tmpValue

cbor/value_test.go

@@ -336,7 +336,10 @@ func TestConstructorDecode(t *testing.T) {
 				testDef.expectedObj.Constructor(),
 			)
 		}
-		if !reflect.DeepEqual(tmpConstr.Fields(), testDef.expectedObj.Fields()) {
+		if !reflect.DeepEqual(
+			tmpConstr.Fields(),
+			testDef.expectedObj.Fields(),
+		) {
 			t.Fatalf(
 				"did not decode to expected fields\n  got:    %#v\n  wanted: %#v",
 				tmpConstr.Fields(),

cmd/gouroboros/chainsync.go

@@ -261,7 +261,11 @@ func testChainSync(f *globalFlags) {
 	select {}
 }
 
-func chainSyncRollBackwardHandler(ctx chainsync.CallbackContext, point common.Point, tip chainsync.Tip) error {
+func chainSyncRollBackwardHandler(
+	ctx chainsync.CallbackContext,
+	point common.Point,
+	tip chainsync.Tip,
+) error {
 	fmt.Printf("roll backward: point = %#v, tip = %#v\n", point, tip)
 	return nil
 }
@@ -318,7 +322,10 @@ func chainSyncRollForwardHandler(
 	return nil
 }
 
-func blockFetchBlockHandler(ctx blockfetch.CallbackContext, blockData ledger.Block) error {
+func blockFetchBlockHandler(
+	ctx blockfetch.CallbackContext,
+	blockData ledger.Block,
+) error {
 	switch block := blockData.(type) {
 	case *ledger.ByronEpochBoundaryBlock:
 		fmt.Printf("era = Byron (EBB), epoch = %d, slot = %d, id = %s\n", block.Header.ConsensusData.Epoch, block.SlotNumber(), block.Hash())

cmd/gouroboros/query.go

@@ -191,7 +191,9 @@ func testQuery(f *globalFlags) {
 			}
 			tmpPools = append(tmpPools, tmpPoolId)
 		}
-		poolParams, err := o.LocalStateQuery().Client.GetStakePoolParams(tmpPools)
+		poolParams, err := o.LocalStateQuery().Client.GetStakePoolParams(
+			tmpPools,
+		)
 		if err != nil {
 			fmt.Printf("ERROR: failure querying stake pool params: %s\n", err)
 			os.Exit(1)

cmd/tx-submission/main.go

@@ -118,7 +118,10 @@ func main() {
 	// convert to tx
 	txType, err := ledger.DetermineTransactionType(txBytes)
 	if err != nil {
-		fmt.Printf("ERROR: could not parse transaction to determine type: %s", err)
+		fmt.Printf(
+			"ERROR: could not parse transaction to determine type: %s",
+			err,
+		)
 		os.Exit(1)
 	}
 	tx, err := ledger.NewTransactionFromCbor(txType, txBytes)

connection.go

@@ -146,7 +146,11 @@ func (c *Connection) Dial(proto string, address string) error {
 // passed to the [net.DialTimeout] func. The handshake will be started when a connection is established.
 // An error will be returned if the connection fails, a connection was already established, or the
 // handshake fails
-func (c *Connection) DialTimeout(proto string, address string, timeout time.Duration) error {
+func (c *Connection) DialTimeout(
+	proto string,
+	address string,
+	timeout time.Duration,
+) error {
 	if c.conn != nil {
 		return fmt.Errorf("a connection was already established")
 	}
@@ -310,17 +314,19 @@ func (c *Connection) setupConnection() error {
 	var handshakeFullDuplex bool
 	handshakeConfig := handshake.NewConfig(
 		handshake.WithProtocolVersionMap(protoVersions),
-		handshake.WithFinishedFunc(func(ctx handshake.CallbackContext, version uint16, versionData protocol.VersionData) error {
-			c.handshakeVersion = version
-			c.handshakeVersionData = versionData
-			if c.useNodeToNodeProto {
-				if versionData.DiffusionMode() == protocol.DiffusionModeInitiatorAndResponder {
-					handshakeFullDuplex = true
+		handshake.WithFinishedFunc(
+			func(ctx handshake.CallbackContext, version uint16, versionData protocol.VersionData) error {
+				c.handshakeVersion = version
+				c.handshakeVersionData = versionData
+				if c.useNodeToNodeProto {
+					if versionData.DiffusionMode() == protocol.DiffusionModeInitiatorAndResponder {
+						handshakeFullDuplex = true
+					}
 				}
-			}
-			close(c.handshakeFinishedChan)
-			return nil
-		}),
+				close(c.handshakeFinishedChan)
+				return nil
+			},
+		),
 	)
 	c.handshake = handshake.New(protoOptions, &handshakeConfig)
 	if c.server {

connection_manager.go

@@ -78,7 +78,11 @@ func NewConnectionManager(cfg ConnectionManagerConfig) *ConnectionManager {
 	}
 }
 
-func (c *ConnectionManager) AddHost(address string, port uint, tags ...ConnectionManagerTag) {
+func (c *ConnectionManager) AddHost(
+	address string,
+	port uint,
+	tags ...ConnectionManagerTag,
+) {
 	tmpTags := map[ConnectionManagerTag]bool{}
 	for _, tag := range tags {
 		tmpTags[tag] = true
@@ -99,12 +103,20 @@ func (c *ConnectionManager) AddHostsFromTopology(topology *TopologyConfig) {
 	}
 	for _, localRoot := range topology.LocalRoots {
 		for _, host := range localRoot.AccessPoints {
-			c.AddHost(host.Address, host.Port, ConnectionManagerTagHostLocalRoot)
+			c.AddHost(
+				host.Address,
+				host.Port,
+				ConnectionManagerTagHostLocalRoot,
+			)
 		}
 	}
 	for _, publicRoot := range topology.PublicRoots {
 		for _, host := range publicRoot.AccessPoints {
-			c.AddHost(host.Address, host.Port, ConnectionManagerTagHostPublicRoot)
+			c.AddHost(
+				host.Address,
+				host.Port,
+				ConnectionManagerTagHostPublicRoot,
+			)
 		}
 	}
 }
@@ -129,13 +141,17 @@ func (c *ConnectionManager) RemoveConnection(connId ConnectionId) {
 	c.connectionsMutex.Unlock()
 }
 
-func (c *ConnectionManager) GetConnectionById(connId ConnectionId) *ConnectionManagerConnection {
+func (c *ConnectionManager) GetConnectionById(
+	connId ConnectionId,
+) *ConnectionManagerConnection {
 	c.connectionsMutex.Lock()
 	defer c.connectionsMutex.Unlock()
 	return c.connections[connId]
 }
 
-func (c *ConnectionManager) GetConnectionsByTags(tags ...ConnectionManagerTag) []*ConnectionManagerConnection {
+func (c *ConnectionManager) GetConnectionsByTags(
+	tags ...ConnectionManagerTag,
+) []*ConnectionManagerConnection {
 	var ret []*ConnectionManagerConnection
 	c.connectionsMutex.Lock()
 	for _, conn := range c.connections {

connection_manager_test.go

@@ -56,10 +56,18 @@ func TestConnectionManagerConnError(t *testing.T) {
 			ConnClosedFunc: func(connId ouroboros.ConnectionId, err error) {
 				if err != nil {
 					if connId != expectedConnId {
-						t.Fatalf("did not receive error from expected connection: got %d, wanted %d", connId, expectedConnId)
+						t.Fatalf(
+							"did not receive error from expected connection: got %d, wanted %d",
+							connId,
+							expectedConnId,
+						)
 					}
 					if err != expectedErr {
-						t.Fatalf("did not receive expected error: got: %s, expected: %s", err, expectedErr)
+						t.Fatalf(
+							"did not receive expected error: got: %s, expected: %s",
+							err,
+							expectedErr,
+						)
 					}
 					close(doneChan)
 				}
@@ -121,7 +129,11 @@ func TestConnectionManagerConnClosed(t *testing.T) {
 		ouroboros.ConnectionManagerConfig{
 			ConnClosedFunc: func(connId ouroboros.ConnectionId, err error) {
 				if connId != expectedConnId {
-					t.Fatalf("did not receive closed signal from expected connection: got %d, wanted %d", connId, expectedConnId)
+					t.Fatalf(
+						"did not receive closed signal from expected connection: got %d, wanted %d",
+						connId,
+						expectedConnId,
+					)
 				}
 				if err != nil {
 					t.Fatalf("received unexpected error: %s", err)

ledger/alonzo.go

@@ -452,10 +452,15 @@ func NewAlonzoTransactionFromCbor(data []byte) (*AlonzoTransaction, error) {
 	return &alonzoTx, nil
 }
 
-func NewAlonzoTransactionOutputFromCbor(data []byte) (*AlonzoTransactionOutput, error) {
+func NewAlonzoTransactionOutputFromCbor(
+	data []byte,
+) (*AlonzoTransactionOutput, error) {
 	var alonzoTxOutput AlonzoTransactionOutput
 	if _, err := cbor.Decode(data, &alonzoTxOutput); err != nil {
-		return nil, fmt.Errorf("Alonzo transaction output decode error: %s", err)
+		return nil, fmt.Errorf(
+			"Alonzo transaction output decode error: %s",
+			err,
+		)
 	}
 	return &alonzoTxOutput, nil
 }