removing unnecessary formatting

light/client.go

@@ -284,16 +284,16 @@ func (c *Client) restoreTrustedLightBlock() error {
 
 // if options.Height:
 //
-//  1. ahead of trustedLightBlock.Height => fetch light blocks (same height as
+//     1) ahead of trustedLightBlock.Height => fetch light blocks (same height as
 //     trustedLightBlock) from primary provider and check it's hash matches the
 //     trustedLightBlock's hash (if not, remove trustedLightBlock and all the light blocks
 //     before)
 //
-//  2. equals trustedLightBlock.Height => check options.Hash matches the
+//     2) equals trustedLightBlock.Height => check options.Hash matches the
 //     trustedLightBlock's hash (if not, remove trustedLightBlock and all the light blocks
 //     before)
 //
-//  3. behind trustedLightBlock.Height => remove all the light blocks between
+//     3) behind trustedLightBlock.Height => remove all the light blocks between
 //     options.Height and trustedLightBlock.Height, update trustedLightBlock, then
 //     check options.Hash matches the trustedLightBlock's hash (if not, remove
 //     trustedLightBlock and all the light blocks before)
@@ -395,10 +395,10 @@ func (c *Client) initializeWithTrustOptions(ctx context.Context, options TrustOp
 // TrustedLightBlock returns a trusted light block at the given height (0 - the latest).
 //
 // It returns an error if:
-//   - there are some issues with the trusted store, although that should not
-//     happen normally;
-//   - negative height is passed;
-//   - header has not been verified yet and is therefore not in the store
+//  - there are some issues with the trusted store, although that should not
+//  happen normally;
+//  - negative height is passed;
+//  - header has not been verified yet and is therefore not in the store
 //
 // Safe for concurrent use by multiple goroutines.
 func (c *Client) TrustedLightBlock(height int64) (*types.LightBlock, error) {
@@ -510,9 +510,8 @@ func (c *Client) VerifyLightBlockAtHeight(ctx context.Context, height int64, now
 //
 // If the header, which is older than the currently trusted header, is
 // requested and the light client does not have it, VerifyHeader will perform:
-//
-//	a) verifySkipping verification if nearest trusted header is found & not expired
-//	b) backwards verification in all other cases
+//		a) verifySkipping verification if nearest trusted header is found & not expired
+//		b) backwards verification in all other cases
 //
 // It returns ErrOldHeaderExpired if the latest trusted header expired.
 //
@@ -981,12 +980,12 @@ func (c *Client) backwards(
 // lightBlockFromPrimary retrieves the lightBlock from the primary provider
 // at the specified height. This method also handles provider behavior as follows:
 //
-//  1. If the provider does not respond or does not have the block, it tries again
-//     with a different provider
-//  2. If all providers return the same error, the light client forwards the error to
-//     where the initial request came from
-//  3. If the provider provides an invalid light block, is deemed unreliable or returns
-//     any other error, the primary is permanently dropped and is replaced by a witness.
+// 1. If the provider does not respond or does not have the block, it tries again
+//    with a different provider
+// 2. If all providers return the same error, the light client forwards the error to
+//    where the initial request came from
+// 3. If the provider provides an invalid light block, is deemed unreliable or returns
+//    any other error, the primary is permanently dropped and is replaced by a witness.
 func (c *Client) lightBlockFromPrimary(ctx context.Context, height int64) (*types.LightBlock, error) {
 	c.providerMutex.Lock()
 	l, err := c.primary.LightBlock(ctx, height)

light/detector.go

@@ -109,9 +109,7 @@ func (c *Client) detectDivergence(ctx context.Context, primaryTrace []*types.Lig
 //
 // 1: errConflictingHeaders -> there may have been an attack on this light client
 // 2: errBadWitness -> the witness has either not responded, doesn't have the header or has given us an invalid one
-//
-//	Note: In the case of an invalid header we remove the witness
-//
+//    Note: In the case of an invalid header we remove the witness
 // 3: nil -> the hashes of the two headers match
 func (c *Client) compareNewHeaderWithWitness(ctx context.Context, errc chan error, h *types.SignedHeader,
 	witness provider.Provider, witnessIndex int) {
@@ -277,16 +275,16 @@ func (c *Client) handleConflictingHeaders(
 // it has received from another and preforms verifySkipping at the heights of each of the intermediate
 // headers in the trace until it reaches the divergentHeader. 1 of 2 things can happen.
 //
-//  1. The light client verifies a header that is different to the intermediate header in the trace. This
-//     is the bifurcation point and the light client can create evidence from it
-//  2. The source stops responding, doesn't have the block or sends an invalid header in which case we
-//     return the error and remove the witness
+// 1. The light client verifies a header that is different to the intermediate header in the trace. This
+//    is the bifurcation point and the light client can create evidence from it
+// 2. The source stops responding, doesn't have the block or sends an invalid header in which case we
+//    return the error and remove the witness
 //
 // CONTRACT:
-//  1. Trace can not be empty len(trace) > 0
-//  2. The last block in the trace can not be of a lower height than the target block
-//     trace[len(trace)-1].Height >= targetBlock.Height
-//  3. The
+// 1. Trace can not be empty len(trace) > 0
+// 2. The last block in the trace can not be of a lower height than the target block
+//    trace[len(trace)-1].Height >= targetBlock.Height
+// 3. The
 func (c *Client) examineConflictingHeaderAgainstTrace(
 	ctx context.Context,
 	trace []*types.LightBlock,

light/doc.go

@@ -63,31 +63,29 @@ This package provides three major things:
 
 Example usage:
 
-	db, err := dbm.NewGoLevelDB("light-client-db", dbDir)
-	if err != nil {
-		// handle error
-	}
-
-	c, err := NewHTTPClient(
-		chainID,
-		TrustOptions{
-			Period: 504 * time.Hour, // 21 days
-			Height: 100,
-			Hash:   header.Hash(),
-		},
-		"http://localhost:26657",
-		[]string{"http://witness1:26657"},
-		dbs.New(db, ""),
-	)
-	if err != nil {
-		// handle error
-	}
-
-	h, err := c.TrustedHeader(100)
-	if err != nil {
-		// handle error
-	}
-	fmt.Println("header", h)
+		db, err := dbm.NewGoLevelDB("light-client-db", dbDir)
+		if err != nil {
+			// handle error
+		}
+		c, err := NewHTTPClient(
+			chainID,
+			TrustOptions{
+				Period: 504 * time.Hour, // 21 days
+				Height: 100,
+				Hash:   header.Hash(),
+			},
+			"http://localhost:26657",
+			[]string{"http://witness1:26657"},
+			dbs.New(db, ""),
+		)
+		if err != nil {
+			// handle error
+		}
+		h, err := c.TrustedHeader(100)
+		if err != nil {
+			// handle error
+		}
+		fmt.Println("header", h)
 
 Check out other examples in example_test.go
 

light/rpc/client.go

@@ -27,7 +27,6 @@ var errNegOrZeroHeight = errors.New("negative or zero height")
 type KeyPathFunc func(path string, key []byte) (merkle.KeyPath, error)
 
 // LightClient is an interface that contains functionality needed by Client from the light client.
-//
 //go:generate ../../scripts/mockery_generate.sh LightClient
 type LightClient interface {
 	ChainID() string

light/verifier.go

@@ -19,13 +19,13 @@ var (
 // VerifyNonAdjacent verifies non-adjacent untrustedHeader against
 // trustedHeader. It ensures that:
 //
-//		a) trustedHeader can still be trusted (if not, ErrOldHeaderExpired is returned)
-//		b) untrustedHeader is valid (if not, ErrInvalidHeader is returned)
-//		c) trustLevel ([1/3, 1]) of trustedHeaderVals (or trustedHeaderNextVals)
-//	 signed correctly (if not, ErrNewValSetCantBeTrusted is returned)
-//		d) more than 2/3 of untrustedVals have signed h2
-//	   (otherwise, ErrInvalidHeader is returned)
-//	 e) headers are non-adjacent.
+//	a) trustedHeader can still be trusted (if not, ErrOldHeaderExpired is returned)
+//	b) untrustedHeader is valid (if not, ErrInvalidHeader is returned)
+//	c) trustLevel ([1/3, 1]) of trustedHeaderVals (or trustedHeaderNextVals)
+//  signed correctly (if not, ErrNewValSetCantBeTrusted is returned)
+//	d) more than 2/3 of untrustedVals have signed h2
+//    (otherwise, ErrInvalidHeader is returned)
+//  e) headers are non-adjacent.
 //
 // maxClockDrift defines how much untrustedHeader.Time can drift into the
 // future.
@@ -81,12 +81,12 @@ func VerifyNonAdjacent(
 // VerifyAdjacent verifies directly adjacent untrustedHeader against
 // trustedHeader. It ensures that:
 //
-//	a) trustedHeader can still be trusted (if not, ErrOldHeaderExpired is returned)
-//	b) untrustedHeader is valid (if not, ErrInvalidHeader is returned)
-//	c) untrustedHeader.ValidatorsHash equals trustedHeader.NextValidatorsHash
-//	d) more than 2/3 of new validators (untrustedVals) have signed h2
-//	  (otherwise, ErrInvalidHeader is returned)
-//	e) headers are adjacent.
+//  a) trustedHeader can still be trusted (if not, ErrOldHeaderExpired is returned)
+//  b) untrustedHeader is valid (if not, ErrInvalidHeader is returned)
+//  c) untrustedHeader.ValidatorsHash equals trustedHeader.NextValidatorsHash
+//  d) more than 2/3 of new validators (untrustedVals) have signed h2
+//    (otherwise, ErrInvalidHeader is returned)
+//  e) headers are adjacent.
 //
 // maxClockDrift defines how much untrustedHeader.Time can drift into the
 // future.
@@ -212,12 +212,12 @@ func HeaderExpired(h *types.SignedHeader, trustingPeriod time.Duration, now time
 // VerifyBackwards verifies an untrusted header with a height one less than
 // that of an adjacent trusted header. It ensures that:
 //
-//		a) untrusted header is valid
-//	 b) untrusted header has a time before the trusted header
-//	 c) that the LastBlockID hash of the trusted header is the same as the hash
-//	 of the trusted header
+// 	a) untrusted header is valid
+//  b) untrusted header has a time before the trusted header
+//  c) that the LastBlockID hash of the trusted header is the same as the hash
+//  of the trusted header
 //
-//	 For any of these cases ErrInvalidHeader is returned.
+//  For any of these cases ErrInvalidHeader is returned.
 func VerifyBackwards(untrustedHeader, trustedHeader *types.Header) error {
 	if err := untrustedHeader.ValidateBasic(); err != nil {
 		return ErrInvalidHeader{err}