In Comsos if the signing is happening through external wallet and signature is getting received on dapp. Is there a way to club the signature and transaction object for broadcast

[punithbm]

We are able to sign the cosmos transaction has from the external client and it is getting generated like this

export const generateCosmosPreSignHash = async (txObject: any) => {
  const walletCore = await initWasm();
  const signingMode = 1;
  const amounts = TW.Cosmos.Proto.Amount.create({
    amount: (txObject.amountValue ?? 0).toString(),
    denom: txObject.denom,
  });
  const sendCoinsMessage = TW.Cosmos.Proto.Message.Send.create({
    toAddress: txObject.toAddress,
    fromAddress: txObject.toAddress,
    amounts: [amounts],
  });
  const message = TW.Cosmos.Proto.Message.create({
    sendCoinsMessage: sendCoinsMessage,
  });
  const gasPrice = String(txObject.gasPrice * txObject.gasLimit).split(".")[0];
  const fee = TW.Cosmos.Proto.Fee.create({
    gas: new Long(txObject.gasLimit),
    amounts: [
      {
        amount: String(gasPrice),
        denom: txObject.denom,
      },
    ],
  });
  const input = TW.Cosmos.Proto.SigningInput.create({
    signingMode: signingMode,
    accountNumber: new Long(Number(txObject.accountNumber)),
    chainId: txObject.chainId,
    memo: "",
    sequence: new Long(Number(txObject.sequence)),
    mode: 0,
    messages: [message],
    fee: fee,
  });
  const encoded = TW.Cosmos.Proto.SigningInput.encode(input).finish();
  return walletCore.HexCoding.encode(encoded);
};

and the signature is done in the external wallet which ever installed. For that we are using

export const getSignedTxHashCosmos = async (signature: string, txObject: any) => {
  const output = TW.Cosmos.Proto.SigningOutput.decode(Buffer.from(signature, "hex"));
  const outputBytes = JSON.parse(output.serialized);
  return outputBytes;
};

But the if we broadcast the output bytes generated when trying, it throws error

[satoshiotomakan]

Hi @punithbm, we have TransactionCompiler.compile function that takes TW.Cosmos.Proto.SigningInput, a list of signatures and a list of public keys. Usually, there should be only one signature and one corresponding public key.
Please take a look at the TypeScript example:

    it("test compile", () => {
        const { PrivateKey, HexCoding, AnyAddress, CoinType, Curve, TransactionCompiler, DataVector } = globalThis.core;

        const signingMode = 1;
        const amounts = TW.Cosmos.Proto.Amount.create({
            amount: "400000",
            denom: "uatom",
        });
        const sendCoinsMessage = TW.Cosmos.Proto.Message.Send.create({
            toAddress: "cosmos18s0hdnsllgcclweu9aymw4ngktr2k0rkygdzdp",
            fromAddress: "cosmos1mky69cn8ektwy0845vec9upsdphktxt03gkwlx",
            amounts: [amounts],
        });
        const message = TW.Cosmos.Proto.Message.create({
            sendCoinsMessage: sendCoinsMessage,
        });
        const fee = TW.Cosmos.Proto.Fee.create({
            gas: new Long(200000),
            amounts: [
                {
                    amount: "1000",
                    denom: "uatom",
                },
            ],
        });
        const input = TW.Cosmos.Proto.SigningInput.create({
            signingMode: signingMode,
            accountNumber: new Long(546179),
            chainId: "cosmoshub-4",
            memo: "",
            sequence: new Long(0),
            // Sign as Protobuf encoded.
            mode: 1,
            messages: [message],
            fee: fee,
            // Must be specified instead of `privateKey`.
            publicKey: HexCoding.decode("02ecef5ce437a302c67f95468de4b31f36e911f467d7e6a52b41c1e13e1d563649"),
        });
        const inputEncoded = TW.Cosmos.Proto.SigningInput.encode(input).finish();

        /// Step 2: Obtain preimage hashes
        const preimageOutputData = TransactionCompiler.preImageHashes(CoinType.cosmos, inputEncoded);
        const preimageOutput = TW.TxCompiler.Proto.PreSigningOutput.decode(preimageOutputData);

        assert.equal(HexCoding.encode(preimageOutput.dataHash), "0xfa7990e1814c900efaedf1bdbedba22c22336675befe0ae39974130fc204f3de");

        /// Step 3: Compile transaction info with an "external" signature.
        const signatures = DataVector.createWithData(HexCoding.decode("afbd513a776f4fdf470ef7f9675f21ae9d630fc4d635d8dbaa0dc0a716434cd07e02510765d4673dfa880825bae8e67cb367396ff6b976fc6b19a31fc95e8097"));
        const publicKeys = DataVector.createWithData(HexCoding.decode("02ecef5ce437a302c67f95468de4b31f36e911f467d7e6a52b41c1e13e1d563649"));

        const outputData = TransactionCompiler.compileWithSignatures(CoinType.cosmos, inputEncoded, signatures, publicKeys);
        const output = TW.Cosmos.Proto.SigningOutput.decode(outputData);

        assert.equal(output.serialized, "{\"mode\":\"BROADCAST_MODE_SYNC\",\"tx_bytes\":\"CpIBCo8BChwvY29zbW9zLmJhbmsudjFiZXRhMS5Nc2dTZW5kEm8KLWNvc21vczFta3k2OWNuOGVrdHd5MDg0NXZlYzl1cHNkcGhrdHh0MDNna3dseBItY29zbW9zMThzMGhkbnNsbGdjY2x3ZXU5YXltdzRuZ2t0cjJrMHJreWdkemRwGg8KBXVhdG9tEgY0MDAwMDASZQpOCkYKHy9jb3Ntb3MuY3J5cHRvLnNlY3AyNTZrMS5QdWJLZXkSIwohAuzvXOQ3owLGf5VGjeSzHzbpEfRn1+alK0HB4T4dVjZJEgQKAggBEhMKDQoFdWF0b20SBDEwMDAQwJoMGkCvvVE6d29P30cO9/lnXyGunWMPxNY12NuqDcCnFkNM0H4CUQdl1Gc9+ogIJbro5nyzZzlv9rl2/GsZox/JXoCX\"}");
    });

[punithbm]

I was trying with protobuf, but shared JSON since its more readable. Do you think account number or sequence not getting set in the signing input when doing the external signature ?

[satoshiotomakan]

It's highly recommended to sign exact the same hash as you got on TransactionCompiler.preImageHashes. Other wallets might serialize the transaction to be signed in a slightly different way that can significantly impact on the transaction hash.
So the workflow looks like this:

1. Generate and the transaction and obtain preimage hash of the tx.
2. Send the transaction hash to an external service.
3. Compile the final transaction with the received signature and the corresponding public key.

[punithbm]

Got it, Thanks for the support

Below is the code I'm using for generating the pre image hashes for the external signature and encoding to broadcast the transaction. But whenever I'm doing, even though I'm getting valid signature - broadcasting fails with the error signature verification failed; please verify account number and chain id . Could you please look into the below code and see if anything is wrong ?

Tx Input encoder for generating the hash for signature

const getCosmosInputEncoded = async (txObject: any, walletCore: WalletCore): Promise<Uint8Array> => {
  const signingMode = 1;
  const amounts = TW.Cosmos.Proto.Amount.create({
    amount: (txObject.amountValue ?? 0).toString(),
    denom: txObject.denom,
  });
  const sendCoinsMessage = TW.Cosmos.Proto.Message.Send.create({
    toAddress: txObject.toAddress,
    fromAddress: txObject.fromAddress,
    amounts: [amounts],
  });
  const message = TW.Cosmos.Proto.Message.create({
    sendCoinsMessage: sendCoinsMessage,
  });
  const gasPrice = String(txObject.gasPrice * txObject.gasLimit).split(".")[0];
  const fee = TW.Cosmos.Proto.Fee.create({
    gas: new Long(txObject.gasLimit),
    amounts: [
      {
        amount: String(gasPrice),
        denom: txObject.denom,
      },
    ],
  });
  const pubKey = getPublicKeyHex();
  const pubData = walletCore.HexCoding.decode(pubKey ?? "");
  const wcPubKey = walletCore.PublicKey.createWithData(pubData, walletCore.PublicKeyType.secp256k1);
  const input = TW.Cosmos.Proto.SigningInput.create({
    signingMode: signingMode,
    accountNumber: new Long(Number(txObject.accountNumber)),
    chainId: txObject.chainId,
    memo: "",
    sequence: new Long(Number(txObject.sequence)),
    mode: 0,
    messages: [message],
    fee: fee,
    publicKey: wcPubKey.data(),
  });
  return TW.Cosmos.Proto.SigningInput.encode(input).finish();
};

Generate the Hash from below function to send it to external signer

const generateCosmosPreSignHash = async (txObject: any): Promise<string> => {
  const inputEncoded = await getCosmosInputEncoded(txObject, walletCore);
  const preimageOutputData = walletCore.TransactionCompiler.preImageHashes(walletCore.CoinType.cosmos, inputEncoded);
  const preimageOutput = TW.TxCompiler.Proto.PreSigningOutput.decode(preimageOutputData);
  const inputDataHashHex = walletCore.HexCoding.encode(preimageOutput.dataHash);
  return inputDataHashHex;
};

Encode the preimage hashes with the signature received from the external signer

const getSignedTxHashCosmos = async (signature: string, txObject: any) => {
  const inputEncoded = await getCosmosInputEncoded(txObject, walletCore);
  const pubKey = getPublicKeyHex();
  const pubData = walletCore.HexCoding.decode(pubKey ?? "");
  const wcPubKey = walletCore.PublicKey.createWithData(pubData, walletCore.PublicKeyType.secp256k1);
  const signData = walletCore.HexCoding.decode(signature);

  const preimageOutputData = walletCore.TransactionCompiler.preImageHashes(walletCore.CoinType.cosmos, inputEncoded);
  const preimageOutput = TW.TxCompiler.Proto.PreSigningOutput.decode(preimageOutputData);
  const inputDataHash = preimageOutput.dataHash;
  const inputDataHashHex = walletCore.HexCoding.encode(inputDataHash);
  const isValid = wcPubKey.compressed().verify(signData, inputDataHash);

  const signatures = walletCore.DataVector.createWithData(signData);
  const publicKeys = walletCore.DataVector.createWithData(wcPubKey.compressed().data());
  const outputData = walletCore.TransactionCompiler.compileWithSignaturesAndPubKeyType(walletCore.CoinType.cosmos, inputEncoded, signatures, publicKeys, walletCore.PublicKeyType.secp256k1);
  const output = TW.Cosmos.Proto.SigningOutput.decode(outputData);
  const outputBytes = JSON.parse(output.serialized);
  return outputBytes;
};

[punithbm]

Figured out the issue, removing the r (recovery) component in the signature and using it resolved. Signature from the external signer was 130 characters length where as last 2 characters were carrying the bytes for recover. Slicing and using it worked.