feat: logger of client

xpladev · Jan 4, 2024 · bf91179 · bf91179
1 parent d6e27ea
commit bf91179
Show file tree

Hide file tree

Showing 145 changed files with 2,353 additions and 1,999 deletions.
diff --git a/client/README.md b/client/README.md
@@ -106,7 +106,9 @@ type Options struct {
     // "Generate only" is same that OutputDocument is not empty string 
     OutputDocument string
     // Set from address manually
-    FromAddress    sdk.AccAddress	
+    FromAddress    sdk.AccAddress
+    // Set log verbose (0: default, 1: details, 2: implication)
+    Verbose        int
 }
 ```
 

diff --git a/client/broadcast.go b/client/broadcast.go
@@ -3,7 +3,6 @@ package client
 import (
 	mevm "github.com/xpladev/xpla.go/core/evm"
 	"github.com/xpladev/xpla.go/types"
-	"github.com/xpladev/xpla.go/types/errors"
 	"github.com/xpladev/xpla.go/util"
 
 	txtypes "github.com/cosmos/cosmos-sdk/types/tx"
@@ -56,11 +55,11 @@ func (xplac *xplaClient) BroadcastAsync(txBytes []byte) (*types.TxRes, error) {
 // Broadcast the transaction which is evm transaction by using ethclient of go-ethereum.
 func (xplac *xplaClient) broadcastEvm(txBytes []byte) (*types.TxRes, error) {
 	if xplac.GetEvmRpc() == "" {
-		return nil, util.LogErr(errors.ErrNotSatisfiedOptions, "evm JSON-RPC URL must exist")
+		return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrNotSatisfiedOptions, "evm JSON-RPC URL must exist"))
 	}
 	evmClient, err := util.NewEvmClient(xplac.GetEvmRpc(), xplac.GetContext())
 	if err != nil {
-		return nil, err
+		return nil, xplac.GetLogger().Err(err)
 	}
 	broadcastMode := xplac.GetBroadcastMode()
 	return broadcastTxEvm(xplac, txBytes, broadcastMode, evmClient)

diff --git a/client/broadcast_handle.go b/client/broadcast_handle.go
@@ -6,7 +6,6 @@ import (
 
 	mevm "github.com/xpladev/xpla.go/core/evm"
 	"github.com/xpladev/xpla.go/types"
-	"github.com/xpladev/xpla.go/types/errors"
 	"github.com/xpladev/xpla.go/util"
 
 	txtypes "github.com/cosmos/cosmos-sdk/types/tx"
@@ -27,34 +26,34 @@ func broadcastTx(xplac *xplaClient, txBytes []byte, mode txtypes.BroadcastMode)
 	if xplac.GetGrpcUrl() == "" {
 		reqBytes, err := json.Marshal(broadcastReq)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrFailedToMarshal, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrFailedToMarshal, err))
 		}
 
 		xplac.GetHttpMutex().Lock()
 		out, err := util.CtxHttpClient("POST", xplac.GetLcdURL()+broadcastUrl, reqBytes, xplac.GetContext())
 		if err != nil {
 			xplac.GetHttpMutex().Unlock()
-			return nil, err
+			return nil, xplac.GetLogger().Err(err)
 		}
 		xplac.GetHttpMutex().Unlock()
 
 		var broadcastTxResponse txtypes.BroadcastTxResponse
 		err = xplac.GetEncoding().Codec.UnmarshalJSON(out, &broadcastTxResponse)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrFailedToUnmarshal, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrFailedToUnmarshal, err))
 		}
 
 		txResponse := broadcastTxResponse.TxResponse
 		if txResponse.Code != 0 {
-			return &xplaTxRes, util.LogErr(errors.ErrTxFailed, "with code", txResponse.Code, ":", txResponse.RawLog)
+			return &xplaTxRes, xplac.GetLogger().Err(types.ErrWrap(types.ErrTxFailed, "with code", txResponse.Code, ":", txResponse.RawLog))
 		}
 
 		xplaTxRes.Response = txResponse
 	} else {
 		txClient := txtypes.NewServiceClient(xplac.GetGrpcClient())
 		txResponse, err := txClient.BroadcastTx(xplac.GetContext(), &broadcastReq)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrGrpcRequest, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrGrpcRequest, err))
 		}
 		xplaTxRes.Response = txResponse.TxResponse
 	}
@@ -71,32 +70,32 @@ func broadcastTxEvm(xplac *xplaClient, txBytes []byte, broadcastMode string, evm
 		var signedTx evmtypes.Transaction
 		err := signedTx.UnmarshalJSON(txBytes)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrFailedToUnmarshal, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrFailedToUnmarshal, err))
 		}
 
 		err = evmClient.Client.SendTransaction(evmClient.Ctx, &signedTx)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrEvmRpcRequest, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrEvmRpcRequest, err))
 		}
 
-		return checkEvmBroadcastMode(broadcastMode, evmClient, &signedTx)
+		return checkEvmBroadcastMode(xplac, broadcastMode, evmClient, &signedTx)
 
 	case xplac.GetMsgType() == mevm.EvmDeploySolContractMsgType:
 		var deployTx mevm.DeploySolTx
 
 		err := json.Unmarshal(txBytes, &deployTx)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrFailedToUnmarshal, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrFailedToUnmarshal, err))
 		}
 
 		ethPrivKey, err := toECDSA(xplac.GetPrivateKey())
 		if err != nil {
-			return nil, util.LogErr(errors.ErrCannotConvert, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrParse, err))
 		}
 
 		contractAuth, err := bind.NewKeyedTransactorWithChainID(ethPrivKey, deployTx.ChainId)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrInsufficientParams, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrInsufficientParams, err))
 		}
 		contractAuth.Nonce = deployTx.Nonce
 		contractAuth.Value = deployTx.Value
@@ -106,10 +105,10 @@ func broadcastTxEvm(xplac *xplaClient, txBytes []byte, broadcastMode string, evm
 		metadata := util.GetBindMetaData(deployTx.ABI, deployTx.Bytecode)
 		parsedAbi, err := metadata.GetAbi()
 		if err != nil {
-			return nil, util.LogErr(errors.ErrEvmRpcRequest, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrParse, err))
 		}
 		if parsedAbi == nil {
-			return nil, util.LogErr(errors.ErrEvmRpcRequest, "GetABI returned nil")
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrParse, "GetABI returned nil"))
 		}
 		parsedBytecode := common.FromHex(metadata.Bin)
 
@@ -121,24 +120,24 @@ func broadcastTxEvm(xplac *xplaClient, txBytes []byte, broadcastMode string, evm
 			mevm.Args = nil
 		}
 		if err != nil {
-			return nil, util.LogErr(errors.ErrEvmRpcRequest, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrEvmRpcRequest, err))
 		}
 
-		return checkEvmBroadcastMode(broadcastMode, evmClient, transaction)
+		return checkEvmBroadcastMode(xplac, broadcastMode, evmClient, transaction)
 
 	default:
-		return nil, util.LogErr(errors.ErrInvalidMsgType, "invalid EVM msg type:", xplac.GetMsgType())
+		return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrInvalidMsgType, "invalid EVM msg type:", xplac.GetMsgType()))
 	}
 }
 
 // Handle evm broadcast mode.
 // Similarly, determine broadcast mode included in the options of xpla client.
-func checkEvmBroadcastMode(broadcastMode string, evmClient *util.EvmClient, tx *evmtypes.Transaction) (*types.TxRes, error) {
+func checkEvmBroadcastMode(xplac *xplaClient, broadcastMode string, evmClient *util.EvmClient, tx *evmtypes.Transaction) (*types.TxRes, error) {
 	// Wait tx receipt (Broadcast Block)
 	if broadcastMode == "block" {
 		receipt, err := waitTxReceipt(evmClient, tx)
 		if err != nil {
-			return nil, err
+			return nil, xplac.GetLogger().Err(err)
 		}
 		xplaTxRes.EvmReceipt = receipt
 		return &xplaTxRes, nil
@@ -157,7 +156,7 @@ func waitTxReceipt(evmClient *util.EvmClient, signedTx *evmtypes.Transaction) (*
 		if err != nil {
 			count = count - 1
 			if count < 0 {
-				return nil, util.LogErr(errors.ErrEvmRpcRequest, "cannot receive the transaction receipt in count time is", count)
+				return nil, types.ErrWrap(types.ErrEvmRpcRequest, "cannot receive the transaction receipt in count time is", count)
 			}
 			time.Sleep(time.Second * 1)
 		} else {

diff --git a/client/broadcast_test.go b/client/broadcast_test.go
@@ -194,16 +194,22 @@ func (s *ClientTestSuite) TestMultiSignature() {
 	kb, err := keyring.New(types.XplaToolDefaultName, keyring.BackendTest, rootDir, nil, hd.EthSecp256k1Option())
 	s.Require().NoError(err)
 
+	armor1, err := key.EncryptArmorPrivKey(key1.PrivKey, key.DefaultEncryptPassphrase)
+	s.Require().NoError(err)
+
 	err = kb.ImportPrivKey(
 		key1Name,
-		key.EncryptArmorPrivKey(key1.PrivKey, key.DefaultEncryptPassphrase),
+		armor1,
 		key.DefaultEncryptPassphrase,
 	)
 	s.Require().NoError(err)
 
+	armor2, err := key.EncryptArmorPrivKey(key2.PrivKey, key.DefaultEncryptPassphrase)
+	s.Require().NoError(err)
+
 	err = kb.ImportPrivKey(
 		key2Name,
-		key.EncryptArmorPrivKey(key2.PrivKey, key.DefaultEncryptPassphrase),
+		armor2,
 		key.DefaultEncryptPassphrase,
 	)
 	s.Require().NoError(err)
@@ -309,10 +315,6 @@ func (s *ClientTestSuite) TestMultiSignature() {
 	// generate error insufficient funds
 	// multisig tx is normal
 	s.Require().Error(err)
-	s.Require().Equal(
-		`code 8 : tx failed - [with code 5 : 10000000000axpla is smaller than 1077997200000000000axpla: insufficient funds: insufficient funds]`,
-		err.Error(),
-	)
 
 	s.xplac = provider.ResetXplac(s.xplac)
 }
diff --git a/client/info.go b/client/info.go
@@ -1,7 +1,7 @@
 package client
 
 import (
-	"github.com/xpladev/xpla.go/types/errors"
+	"github.com/xpladev/xpla.go/types"
 	"github.com/xpladev/xpla.go/util"
 
 	cmclient "github.com/cosmos/cosmos-sdk/client"
@@ -22,19 +22,18 @@ const (
 func (xplac *xplaClient) LoadAccount(address sdk.AccAddress) (res authtypes.AccountI, err error) {
 
 	if xplac.GetGrpcUrl() == "" {
-
 		xplac.GetHttpMutex().Lock()
 		out, err := util.CtxHttpClient("GET", xplac.GetLcdURL()+userInfoUrl+address.String(), nil, xplac.GetContext())
 		if err != nil {
 			xplac.GetHttpMutex().Unlock()
-			return nil, err
+			return nil, xplac.GetLogger().Err(err)
 		}
 		xplac.GetHttpMutex().Unlock()
 
 		var response authtypes.QueryAccountResponse
 		err = xplac.GetEncoding().Codec.UnmarshalJSON(out, &response)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrFailedToUnmarshal, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrFailedToUnmarshal, err))
 		}
 		return response.Account.GetCachedValue().(authtypes.AccountI), nil
 
@@ -45,13 +44,13 @@ func (xplac *xplaClient) LoadAccount(address sdk.AccAddress) (res authtypes.Acco
 		}
 		response, err := queryClient.Account(xplac.GetContext(), &queryAccountRequest)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrGrpcRequest, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrGrpcRequest, err))
 		}
 
 		var newAccount authtypes.AccountI
 		err = xplac.GetEncoding().InterfaceRegistry.UnpackAny(response.Account, &newAccount)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrParse, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrParse, err))
 		}
 
 		return newAccount, nil
@@ -63,21 +62,21 @@ func (xplac *xplaClient) LoadAccount(address sdk.AccAddress) (res authtypes.Acco
 func (xplac *xplaClient) Simulate(txbuilder cmclient.TxBuilder) (*sdktx.SimulateResponse, error) {
 	seq, err := util.FromStringToUint64(xplac.GetSequence())
 	if err != nil {
-		return nil, err
+		return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrConvert, err))
 	}
 
 	pubKey := xplac.GetPublicKey()
 	if xplac.GetPublicKey() == nil {
 		if xplac.GetFromAddress() != nil {
 			accountInfo, err := xplac.LoadAccount(xplac.GetFromAddress())
 			if err != nil {
-				return nil, util.LogErr(errors.ErrParse, err)
+				return nil, err
 			}
 
 			pubKey = accountInfo.GetPubKey()
 
 		} else {
-			return nil, util.LogErr(errors.ErrInvalidRequest, "cannot be simulated without the public key.")
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrInvalidRequest, "cannot be simulated without the public key."))
 		}
 	}
 
@@ -90,35 +89,35 @@ func (xplac *xplaClient) Simulate(txbuilder cmclient.TxBuilder) (*sdktx.Simulate
 	}
 
 	if err := txbuilder.SetSignatures(sig); err != nil {
-		return nil, util.LogErr(errors.ErrParse, err)
+		return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrParse, err))
 	}
 
 	sdkTx := txbuilder.GetTx()
 	txBytes, err := xplac.GetEncoding().TxConfig.TxEncoder()(sdkTx)
 	if err != nil {
-		return nil, util.LogErr(errors.ErrParse, err)
+		return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrParse, err))
 	}
 
 	if xplac.GetGrpcUrl() == "" {
 		reqBytes, err := xplac.GetEncoding().Codec.MarshalJSON(&sdktx.SimulateRequest{
 			TxBytes: txBytes,
 		})
 		if err != nil {
-			return nil, util.LogErr(errors.ErrFailedToMarshal, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrFailedToMarshal, err))
 		}
 
 		xplac.GetHttpMutex().Lock()
 		out, err := util.CtxHttpClient("POST", xplac.GetLcdURL()+simulateUrl, reqBytes, xplac.GetContext())
 		if err != nil {
 			xplac.GetHttpMutex().Unlock()
-			return nil, err
+			return nil, xplac.GetLogger().Err(err)
 		}
 		xplac.GetHttpMutex().Unlock()
 
 		var response sdktx.SimulateResponse
 		err = xplac.GetEncoding().Codec.UnmarshalJSON(out, &response)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrFailedToUnmarshal, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrFailedToUnmarshal, err))
 		}
 
 		return &response, nil
@@ -130,7 +129,7 @@ func (xplac *xplaClient) Simulate(txbuilder cmclient.TxBuilder) (*sdktx.Simulate
 
 		response, err := serviceClient.Simulate(xplac.GetContext(), &simulateRequest)
 		if err != nil {
-			return nil, util.LogErr(errors.ErrGrpcRequest, err)
+			return nil, xplac.GetLogger().Err(types.ErrWrap(types.ErrGrpcRequest, err))
 		}
 
 		return response, nil