Transaction loses signer info when being sent to the server

[areller]

I'm trying to send a vote transaction programatically. I have something like this

import (
  "github.com/cosmos/cosmos-sdk/client/tx"
  "github.com/cosmos/cosmos-sdk/crypto/keyring"
  "github.com/cosmos/cosmos-sdk/simapp"
  txTypes "github.com/cosmos/cosmos-sdk/types/tx"
  govTypes "github.com/cosmos/cosmos-sdk/x/gov/types"
  ...
)

kr := keyring.NewInMemory()
// import keys...

encCfg := simapp.MakeTestEncodingConfig()
govTypes.RegisterInterfaces(encCfg.InterfaceRegistry)
txConf := encCfg.TxConfig

txf := tx.Factory{}.
  WithTxConfig(txConf).
  WithKeybase(kr).
  WithChainID("...").
  WithGasPrices("...").
  WithGasAdjustment(...).
  WithGas(...)

txBuilder, err := tx.BuildUnsignedTx(txf)
handleError(err)

voteMsg := govTypes.NewMsgVote(k.GetAddress(), ..., govTypes.OptionYes)
err = voteMsg.ValidateBasic()
handleError(err)

txBuilder.SetMsgs(voteMsg)

err = tx.Sign(txf, "owner_key", txBuilder, true)
handleError(err)

actualTx := txBuilder.GetTx()
txBytes, err := txConf.TxEncoder()(actualTx)
handleError(err)

// this prints the signed transaction bytes
fmt.Println(txBytes)

if nodeURI != "" {
  err := grpcSend(nodeURI, txBytes)
  handleError(err)
}

The grpcSend function looks like

func grpcSend(nodeURI string, txBytes []byte) error {
  grpcConn, err := grpc.Dial(
    nodeURI,
    grpc.WithInsecure(),
  )
  if err != nil {
    return err
  }
  defer grpcConn.Close()
  
  txClient := txTypes.NewServiceClient(grpcConn)
  res, err := txClient.BroadcastTx(context.Background(), &txTypes.BroadcastTxRequest{
    Mode:    txTypes.BroadcastMode_BROADCAST_MODE_SYNC,
    TxBytes: txBytes,
  })
  if err != nil {
    return err
  }
  
  fmt.Println(res.TxResponse.Code)
  fmt.Println(res.TxResponse.RawLog)
  return nil
}

The transaction gets built and signed and everything is fine up until the moment I send the transaction and get a response

The response says

pubKey does not match signer address  with signer index: 0: invalid pubkey

Looks like this response is coming from this section of the code

cosmos-sdk/x/auth/ante/sigverify.go

Lines 79 to 80 in a3a0124

	return ctx, sdkerrors.Wrapf(sdkerrors.ErrInvalidPubKey,
	"pubKey does not match signer address %s with signer index: %d", signers[i], i)

I tried to simulate the thing that it's doing locally by decoding txBytes and casting to a SigVerifiableTx interface, trying to get the signer

decodedTx, err := txConf.TxDecoder()(txBytes)
handleError(err)

stx, ok := decodedTx.(authsigning.SigVerifiableTx)
handleError(err)
fmt.Println(stx.GetSigners()[0])

but it gets printed fine

Looks like something gets lost specifically when it's being sent over GRPC. not sure

Any ideas?

[alexanderbez]

	if err = tx.Sign(txf, clientCtx.GetFromName(), unsignedTx, true); err != nil {
		return nil, err
	}

	txBytes, err := clientCtx.TxConfig.TxEncoder()(unsignedTx.GetTx())
	if err != nil {
		return nil, err
	}

	return clientCtx.BroadcastTx(txBytes)

Is the correct way to do it, which is what you seem to be doing as well...so I'm not sure what's going on. Thoughts @AmauryM ?

[areller]

@alexanderbez ohh I see
My goal was to make a script that is generic across all cosmos sdk protocols (gaia, provenance, etc...)
but each one could have a different codec?

[alexanderbez]

Yes, of course. Each app has it's own types, messages, interfaces, etc...So you have to use the app's codec.

[areller]

@alexanderbez makes sense. thanks for clarifying this 🙏

[robert-zaremba]

hmm, how can a client (eg javascript) know how to get the codec? I was always doing this within the node.

[alexanderbez]

This is specific to Golang -- other languages, I have no idea.