github.com/cosmos/cosmos-sdk@v0.50.10/x/auth/migrations/legacytx/stdtx_builder.go (about)

     1  package legacytx
     2  
     3  import (
     4  	"github.com/cosmos/cosmos-sdk/codec"
     5  	sdk "github.com/cosmos/cosmos-sdk/types"
     6  	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
     7  	"github.com/cosmos/cosmos-sdk/types/tx"
     8  	"github.com/cosmos/cosmos-sdk/types/tx/signing"
     9  )
    10  
    11  // StdTxBuilder wraps StdTx to implement to the context.TxBuilder interface.
    12  // Note that this type just exists for backwards compatibility with amino StdTx
    13  // and will not work for protobuf transactions.
    14  type StdTxBuilder struct {
    15  	StdTx
    16  	cdc *codec.LegacyAmino
    17  }
    18  
    19  // SetMsgs implements TxBuilder.SetMsgs
    20  func (s *StdTxBuilder) SetMsgs(msgs ...sdk.Msg) error {
    21  	s.Msgs = msgs
    22  	return nil
    23  }
    24  
    25  // SetSignatures implements TxBuilder.SetSignatures.
    26  func (s *StdTxBuilder) SetSignatures(signatures ...signing.SignatureV2) error {
    27  	sigs := make([]StdSignature, len(signatures))
    28  	var err error
    29  	for i, sig := range signatures {
    30  		sigs[i], err = SignatureV2ToStdSignature(s.cdc, sig)
    31  		if err != nil {
    32  			return err
    33  		}
    34  	}
    35  
    36  	s.Signatures = sigs
    37  	return nil
    38  }
    39  
    40  func (s *StdTxBuilder) SetFeeAmount(amount sdk.Coins) {
    41  	s.StdTx.Fee.Amount = amount
    42  }
    43  
    44  func (s *StdTxBuilder) SetGasLimit(limit uint64) {
    45  	s.StdTx.Fee.Gas = limit
    46  }
    47  
    48  // SetMemo implements TxBuilder.SetMemo
    49  func (s *StdTxBuilder) SetMemo(memo string) {
    50  	s.Memo = memo
    51  }
    52  
    53  // SetTimeoutHeight sets the transaction's height timeout.
    54  func (s *StdTxBuilder) SetTimeoutHeight(height uint64) {
    55  	s.TimeoutHeight = height
    56  }
    57  
    58  // SetFeeGranter does nothing for stdtx
    59  func (s *StdTxBuilder) SetFeeGranter(_ sdk.AccAddress) {}
    60  
    61  // SetFeePayer does nothing for stdtx
    62  func (s *StdTxBuilder) SetFeePayer(_ sdk.AccAddress) {}
    63  
    64  // AddAuxSignerData returns an error for StdTxBuilder.
    65  func (s *StdTxBuilder) AddAuxSignerData(_ tx.AuxSignerData) error {
    66  	return sdkerrors.ErrLogic.Wrap("cannot use AuxSignerData with StdTxBuilder")
    67  }
    68  
    69  // StdTxConfig is a context.TxConfig for StdTx
    70  type StdTxConfig struct {
    71  	Cdc *codec.LegacyAmino
    72  }
    73  
    74  // MarshalTx implements TxConfig.MarshalTx
    75  func (s StdTxConfig) TxEncoder() sdk.TxEncoder {
    76  	return DefaultTxEncoder(s.Cdc)
    77  }
    78  
    79  func (s StdTxConfig) TxJSONEncoder() sdk.TxEncoder {
    80  	return func(tx sdk.Tx) ([]byte, error) {
    81  		return s.Cdc.MarshalJSON(tx)
    82  	}
    83  }
    84  
    85  func (s StdTxConfig) MarshalSignatureJSON(sigs []signing.SignatureV2) ([]byte, error) {
    86  	stdSigs := make([]StdSignature, len(sigs))
    87  	for i, sig := range sigs {
    88  		stdSig, err := SignatureV2ToStdSignature(s.Cdc, sig)
    89  		if err != nil {
    90  			return nil, err
    91  		}
    92  
    93  		stdSigs[i] = stdSig
    94  	}
    95  	return s.Cdc.MarshalJSON(stdSigs)
    96  }
    97  
    98  func (s StdTxConfig) UnmarshalSignatureJSON(bz []byte) ([]signing.SignatureV2, error) {
    99  	var stdSigs []StdSignature
   100  	err := s.Cdc.UnmarshalJSON(bz, &stdSigs)
   101  	if err != nil {
   102  		return nil, err
   103  	}
   104  
   105  	sigs := make([]signing.SignatureV2, len(stdSigs))
   106  	for i, stdSig := range stdSigs {
   107  		sig, err := StdSignatureToSignatureV2(s.Cdc, stdSig)
   108  		if err != nil {
   109  			return nil, err
   110  		}
   111  		sigs[i] = sig
   112  	}
   113  
   114  	return sigs, nil
   115  }
   116  
   117  // SignatureV2ToStdSignature converts a SignatureV2 to a StdSignature
   118  // [Deprecated]
   119  func SignatureV2ToStdSignature(cdc *codec.LegacyAmino, sig signing.SignatureV2) (StdSignature, error) {
   120  	var (
   121  		sigBz []byte
   122  		err   error
   123  	)
   124  
   125  	if sig.Data != nil {
   126  		sigBz, err = SignatureDataToAminoSignature(cdc, sig.Data)
   127  		if err != nil {
   128  			return StdSignature{}, err
   129  		}
   130  	}
   131  
   132  	return StdSignature{
   133  		PubKey:    sig.PubKey,
   134  		Signature: sigBz,
   135  	}, nil
   136  }
   137  
   138  // Unmarshaler is a generic type for Unmarshal functions
   139  type Unmarshaler func(bytes []byte, ptr interface{}) error
   140  
   141  // DefaultTxEncoder logic for standard transaction encoding
   142  func DefaultTxEncoder(cdc *codec.LegacyAmino) sdk.TxEncoder {
   143  	return func(tx sdk.Tx) ([]byte, error) {
   144  		return cdc.Marshal(tx)
   145  	}
   146  }