Merge pull request #154 from abicky/use-context-appropriately

Resolve context.TODO() and add context argument

Author: siburu

.github/workflows/test.yml

@@ -19,14 +19,6 @@ jobs:
         with:
           go-version: 1.21
         id: go
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
       - name: Run Unit test
         run: make test
       - name: Build

chains/tendermint/chain.go

@@ -144,7 +144,7 @@ func (c *Chain) SetupForRelay(ctx context.Context) error {
 
 // LatestHeight queries the chain for the latest height and returns it
 func (c *Chain) LatestHeight(ctx context.Context) (ibcexported.Height, error) {
-	res, err := c.Client.Status(context.Background())
+	res, err := c.Client.Status(ctx)
 	if err != nil {
 		return nil, err
 	} else if res.SyncInfo.CatchingUp {
@@ -156,7 +156,7 @@ func (c *Chain) LatestHeight(ctx context.Context) (ibcexported.Height, error) {
 
 func (c *Chain) Timestamp(ctx context.Context, height ibcexported.Height) (time.Time, error) {
 	ht := int64(height.GetRevisionHeight())
-	if header, err := c.Client.Header(context.TODO(), &ht); err != nil {
+	if header, err := c.Client.Header(ctx, &ht); err != nil {
 		return time.Time{}, err
 	} else {
 		return header.Header.Time, nil
@@ -172,10 +172,10 @@ func (c *Chain) RegisterMsgEventListener(listener core.MsgEventListener) {
 	c.msgEventListener = listener
 }
 
-func (c *Chain) sendMsgs(msgs []sdk.Msg) (*sdk.TxResponse, error) {
+func (c *Chain) sendMsgs(ctx context.Context, msgs []sdk.Msg) (*sdk.TxResponse, error) {
 	logger := GetChainLogger()
 	// broadcast tx
-	res, _, err := c.rawSendMsgs(msgs)
+	res, _, err := c.rawSendMsgs(ctx, msgs)
 	if err != nil {
 		return nil, err
 	} else if res.Code != 0 {
@@ -184,7 +184,7 @@ func (c *Chain) sendMsgs(msgs []sdk.Msg) (*sdk.TxResponse, error) {
 	}
 
 	// wait for tx being committed
-	if resTx, err := c.waitForCommit(res.TxHash); err != nil {
+	if resTx, err := c.waitForCommit(ctx, res.TxHash); err != nil {
 		return nil, err
 	} else if resTx.TxResult.IsErr() {
 		// DeliverTx failed
@@ -193,7 +193,7 @@ func (c *Chain) sendMsgs(msgs []sdk.Msg) (*sdk.TxResponse, error) {
 
 	// call msgEventListener if needed
 	if c.msgEventListener != nil {
-		if err := c.msgEventListener.OnSentMsg(context.TODO(), msgs); err != nil {
+		if err := c.msgEventListener.OnSentMsg(ctx, msgs); err != nil {
 			logger.Error("failed to OnSendMsg call", err)
 			return res, nil
 		}
@@ -202,20 +202,23 @@ func (c *Chain) sendMsgs(msgs []sdk.Msg) (*sdk.TxResponse, error) {
 	return res, nil
 }
 
-func (c *Chain) rawSendMsgs(msgs []sdk.Msg) (*sdk.TxResponse, bool, error) {
+func (c *Chain) rawSendMsgs(ctx context.Context, msgs []sdk.Msg) (*sdk.TxResponse, bool, error) {
 	// Instantiate the client context
-	ctx := c.CLIContext(0)
+	// NOTE: Although cosmos-sdk does not currently use CmdContext in Context.QueryWithData,
+	//   set ctx to clientCtx in case cosmos-sdk uses it in the future.
+	//   (cf. https://github.com/cosmos/cosmos-sdk/blob/v0.50.5/client/query.go#L98, https://github.com/cosmos/cosmos-sdk/blob/v0.50.5/x/auth/types/account_retriever.go#L39, etc.)
+	clientCtx := c.CLIContext(0).WithCmdContext(ctx)
 
 	// Query account details
-	txf, err := prepareFactory(ctx, c.TxFactory(0))
+	txf, err := prepareFactory(clientCtx, c.TxFactory(0))
 	if err != nil {
 		return nil, false, err
 	}
 
 	// TODO: Make this work with new CalculateGas method
 	// https://github.com/cosmos/cosmos-sdk/blob/5725659684fc93790a63981c653feee33ecf3225/client/tx/tx.go#L297
 	// If users pass gas adjustment, then calculate gas
-	_, adjusted, err := CalculateGas(ctx.QueryWithData, txf, msgs...)
+	_, adjusted, err := CalculateGas(clientCtx.QueryWithData, txf, msgs...)
 	if err != nil {
 		return nil, false, err
 	}
@@ -230,19 +233,19 @@ func (c *Chain) rawSendMsgs(msgs []sdk.Msg) (*sdk.TxResponse, bool, error) {
 	}
 
 	// Attach the signature to the transaction
-	err = tx.Sign(context.TODO(), txf, c.config.Key, txb, false)
+	err = tx.Sign(ctx, txf, c.config.Key, txb, false)
 	if err != nil {
 		return nil, false, err
 	}
 
 	// Generate the transaction bytes
-	txBytes, err := ctx.TxConfig.TxEncoder()(txb.GetTx())
+	txBytes, err := clientCtx.TxConfig.TxEncoder()(txb.GetTx())
 	if err != nil {
 		return nil, false, err
 	}
 
 	// Broadcast those bytes
-	res, err := ctx.BroadcastTx(txBytes)
+	res, err := clientCtx.BroadcastTx(txBytes)
 	if err != nil {
 		return nil, false, err
 	}
@@ -259,7 +262,7 @@ func (c *Chain) rawSendMsgs(msgs []sdk.Msg) (*sdk.TxResponse, bool, error) {
 	return res, true, nil
 }
 
-func (c *Chain) waitForCommit(txHash string) (*coretypes.ResultTx, error) {
+func (c *Chain) waitForCommit(ctx context.Context, txHash string) (*coretypes.ResultTx, error) {
 	var resTx *coretypes.ResultTx
 
 	retryInterval := c.AverageBlockTime()
@@ -268,7 +271,7 @@ func (c *Chain) waitForCommit(txHash string) (*coretypes.ResultTx, error) {
 	if err := retry.Do(func() error {
 		var err error
 		var recoverable bool
-		resTx, recoverable, err = c.rawQueryTx(txHash)
+		resTx, recoverable, err = c.rawQueryTx(ctx, txHash)
 		if err != nil {
 			if recoverable {
 				return err
@@ -280,13 +283,13 @@ func (c *Chain) waitForCommit(txHash string) (*coretypes.ResultTx, error) {
 		// proofs of states updated up to height N are available.
 		// In order to make the proof of the state updated by a tx available just after `sendMsgs`,
 		// `waitForCommit` must wait until the latest height is greater than the tx height.
-		if height, err := c.LatestHeight(context.TODO()); err != nil {
+		if height, err := c.LatestHeight(ctx); err != nil {
 			return fmt.Errorf("failed to obtain latest height: %v", err)
 		} else if height.GetRevisionHeight() <= uint64(resTx.Height) {
 			return fmt.Errorf("latest_height(%v) is less than or equal to tx_height(%v) yet", height, resTx.Height)
 		}
 		return nil
-	}, retry.Attempts(maxRetry), retry.Delay(retryInterval), rtyErr); err != nil {
+	}, retry.Context(ctx), retry.Attempts(maxRetry), retry.Delay(retryInterval), rtyErr); err != nil {
 		return resTx, fmt.Errorf("failed to make sure that tx is committed: %v", err)
 	}
 
@@ -295,20 +298,20 @@ func (c *Chain) waitForCommit(txHash string) (*coretypes.ResultTx, error) {
 
 // rawQueryTx returns a tx of which hash equals to `hexTxHash`.
 // If the RPC is successful but the tx is not found, this returns nil with nil error.
-func (c *Chain) rawQueryTx(hexTxHash string) (*coretypes.ResultTx, bool, error) {
-	ctx := c.CLIContext(0)
+func (c *Chain) rawQueryTx(ctx context.Context, hexTxHash string) (*coretypes.ResultTx, bool, error) {
+	clientCtx := c.CLIContext(0).WithCmdContext(ctx)
 
 	txHash, err := hex.DecodeString(hexTxHash)
 	if err != nil {
 		return nil, false, fmt.Errorf("failed to decode the hex string of tx hash: %v", err)
 	}
 
-	node, err := ctx.GetNode()
+	node, err := clientCtx.GetNode()
 	if err != nil {
 		return nil, false, fmt.Errorf("failed to get node: %v", err)
 	}
 
-	resTx, err := node.Tx(context.TODO(), txHash, false)
+	resTx, err := node.Tx(ctx, txHash, false)
 	if err != nil {
 		recoverable := !strings.Contains(err.Error(), "transaction indexing is disabled")
 		return nil, recoverable, fmt.Errorf("failed to retrieve tx: %v", err)
@@ -406,7 +409,7 @@ func CalculateGas(
 
 func (c *Chain) SendMsgs(ctx context.Context, msgs []sdk.Msg) ([]core.MsgID, error) {
 	// Broadcast those bytes
-	res, err := c.sendMsgs(msgs)
+	res, err := c.sendMsgs(ctx, msgs)
 	if err != nil {
 		return nil, err
 	}
@@ -427,7 +430,7 @@ func (c *Chain) GetMsgResult(ctx context.Context, id core.MsgID) (core.MsgResult
 	}
 
 	// find tx
-	resTx, err := c.waitForCommit(msgID.TxHash)
+	resTx, err := c.waitForCommit(ctx, msgID.TxHash)
 	if err != nil {
 		return nil, fmt.Errorf("failed to query tx: %v", err)
 	}

chains/tendermint/cmd/light.go

@@ -43,7 +43,7 @@ func initLightCmd(ctx *config.Context) *cobra.Command {
 			chain := c.Chain.(*tendermint.Chain)
 			prover := c.Prover.(*tendermint.Prover)
 
-			db, df, err := prover.NewLightDB()
+			db, df, err := prover.NewLightDB(cmd.Context())
 			if err != nil {
 				return err
 			}
@@ -64,13 +64,13 @@ func initLightCmd(ctx *config.Context) *cobra.Command {
 
 			switch {
 			case force: // force initialization from trusted node
-				_, err := prover.LightClientWithoutTrust(db)
+				_, err := prover.LightClientWithoutTrust(cmd.Context(), db)
 				if err != nil {
 					return err
 				}
 				fmt.Printf("successfully created light client for %s by trusting endpoint %s...\n", chain.ChainID(), chain.Config().RpcAddr)
 			case height > 0 && len(hash) > 0: // height and hash are given
-				_, err = prover.LightClientWithTrust(db, prover.TrustOptions(height, hash))
+				_, err = prover.LightClientWithTrust(cmd.Context(), db, prover.TrustOptions(height, hash))
 				if err != nil {
 					return wrapInitFailed(err)
 				}
@@ -98,12 +98,12 @@ func updateLightCmd(ctx *config.Context) *cobra.Command {
 			}
 			prover := c.Prover.(*tendermint.Prover)
 
-			bh, err := prover.GetLatestLightHeader()
+			bh, err := prover.GetLatestLightHeader(cmd.Context())
 			if err != nil {
 				return err
 			}
 
-			ah, err := prover.UpdateLightClient(0)
+			ah, err := prover.UpdateLightClient(cmd.Context(), 0)
 			if err != nil {
 				return err
 			}
@@ -136,7 +136,7 @@ func lightHeaderCmd(ctx *config.Context) *cobra.Command {
 
 			switch len(args) {
 			case 1:
-				header, err = prover.GetLatestLightHeader()
+				header, err = prover.GetLatestLightHeader(cmd.Context())
 				if err != nil {
 					return err
 				}
@@ -148,7 +148,7 @@ func lightHeaderCmd(ctx *config.Context) *cobra.Command {
 				}
 
 				if height == 0 {
-					height, err = prover.GetLatestLightHeight()
+					height, err = prover.GetLatestLightHeight(cmd.Context())
 					if err != nil {
 						return err
 					}
@@ -158,7 +158,7 @@ func lightHeaderCmd(ctx *config.Context) *cobra.Command {
 					}
 				}
 
-				header, err = prover.GetLightSignedHeaderAtHeight(height)
+				header, err = prover.GetLightSignedHeaderAtHeight(cmd.Context(), height)
 				if err != nil {
 					return err
 				}
@@ -181,7 +181,7 @@ func deleteLightCmd(ctx *config.Context) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:     "delete [chain-id]",
 		Aliases: []string{"d"},
-		Short:   "wipe the light client database, forcing re-initialzation on the next run",
+		Short:   "wipe the light client database, forcing re-initialization on the next run",
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			c, err := ctx.Config.GetChain(args[0])

chains/tendermint/light.go

@@ -55,15 +55,15 @@ func (pr *Prover) LightHTTP() lightp.Provider {
 	return cl
 }
 
-func (pr *Prover) NewLightDB() (db *dbm.GoLevelDB, df func(), err error) {
+func (pr *Prover) NewLightDB(ctx context.Context) (db *dbm.GoLevelDB, df func(), err error) {
 	c := pr.chain
 	if err := retry.Do(func() error {
 		db, err = dbm.NewGoLevelDB(c.config.ChainId, lightDir(c.HomePath))
 		if err != nil {
 			return fmt.Errorf("can't open light client database: %w", err)
 		}
 		return nil
-	}, rtyAtt, rtyDel, rtyErr); err != nil {
+	}, rtyAtt, rtyDel, rtyErr, retry.Context(ctx)); err != nil {
 		return nil, nil, err
 	}
 
@@ -84,10 +84,10 @@ func (pr *Prover) DeleteLightDB() error {
 
 // LightClientWithTrust takes a header from the chain and attempts to add that header to the light
 // database.
-func (pr *Prover) LightClientWithTrust(db dbm.DB, to light.TrustOptions) (*light.Client, error) {
+func (pr *Prover) LightClientWithTrust(ctx context.Context, db dbm.DB, to light.TrustOptions) (*light.Client, error) {
 	prov := pr.LightHTTP()
 	return light.NewClient(
-		context.Background(),
+		ctx,
 		pr.chain.config.ChainId,
 		to,
 		prov,
@@ -98,24 +98,24 @@ func (pr *Prover) LightClientWithTrust(db dbm.DB, to light.TrustOptions) (*light
 		logger)
 }
 
-// LightClientWithoutTrust querys the latest header from the chain and initializes a new light client
+// LightClientWithoutTrust queries the latest header from the chain and initializes a new light client
 // database using that header. This should only be called when first initializing the light client
-func (pr *Prover) LightClientWithoutTrust(db dbm.DB) (*light.Client, error) {
+func (pr *Prover) LightClientWithoutTrust(ctx context.Context, db dbm.DB) (*light.Client, error) {
 	var (
 		height int64
 		err    error
 	)
 	prov := pr.LightHTTP()
 
 	if err := retry.Do(func() error {
-		h, err := pr.chain.LatestHeight(context.TODO())
+		h, err := pr.chain.LatestHeight(ctx)
 		switch {
 		case err != nil:
 			return err
 		case h.GetRevisionHeight() == 0:
 			return fmt.Errorf("shouldn't be here")
 		default:
-			t, err := pr.chain.Timestamp(context.TODO(), h)
+			t, err := pr.chain.Timestamp(ctx, h)
 			if err != nil {
 				return err
 			}
@@ -125,16 +125,16 @@ func (pr *Prover) LightClientWithoutTrust(db dbm.DB) (*light.Client, error) {
 			height = int64(h.GetRevisionHeight())
 			return nil
 		}
-	}, rtyAtt, rtyDel, rtyErr); err != nil {
+	}, rtyAtt, rtyDel, rtyErr, retry.Context(ctx)); err != nil {
 		return nil, err
 	}
 
-	lb, err := prov.LightBlock(context.Background(), height)
+	lb, err := prov.LightBlock(ctx, height)
 	if err != nil {
 		return nil, err
 	}
 	return light.NewClient(
-		context.Background(),
+		ctx,
 		pr.chain.config.ChainId,
 		light.TrustOptions{
 			Period: pr.getTrustingPeriod(),
@@ -150,14 +150,14 @@ func (pr *Prover) LightClientWithoutTrust(db dbm.DB) (*light.Client, error) {
 }
 
 // GetLatestLightHeader returns the header to be used for client creation
-func (pr *Prover) GetLatestLightHeader() (*tmclient.Header, error) {
-	return pr.GetLightSignedHeaderAtHeight(0)
+func (pr *Prover) GetLatestLightHeader(ctx context.Context) (*tmclient.Header, error) {
+	return pr.GetLightSignedHeaderAtHeight(ctx, 0)
 }
 
 // GetLightSignedHeaderAtHeight returns a signed header at a particular height.
-func (pr *Prover) GetLightSignedHeaderAtHeight(height int64) (*tmclient.Header, error) {
+func (pr *Prover) GetLightSignedHeaderAtHeight(ctx context.Context, height int64) (*tmclient.Header, error) {
 	// create database connection
-	db, df, err := pr.NewLightDB()
+	db, df, err := pr.NewLightDB(ctx)
 	if err != nil {
 		return nil, err
 	}