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.

[codefuturance]

We are trying to use TypeScript SDKs and encountering this error. Would switching to Go solve this issue? Could anyone provide guidance or assistance with this?

We're encountering the error "pubKey does not match signer address inj1... with signer index: 0: invalid pubkey" when attempting to send a transaction.

We're retrieving both the public key and address from the same wallet. The address derived from the public key matches the address directly fetched from the wallet.

[codefuturance]

The issue has been fixed as noted in the following link: GitHub Issue #507.