Fix Reveal Operations for Seoul Protocol (#4557)

* Since the Seoul protocol, reveal operations require the presence of a boolean for whether or not the proof field is present. This is required when manually forging bytes. Added.

* Fix TezosTests.swift

* Fix TezosTests.swift

* Update tests

* Update tests

* Fix TezosCompiler.CompileWithSignatures

* Fix TezosCompiler.CompileWithSignatures

* fix(tezos): Fix Tezos compile test

* fix(tezos): Fix Tezos signing test

* fix(tezos): Add mainnet test transaction

---------

Co-authored-by: gupnik <[email protected]>
Co-authored-by: Sergei Boiko <[email protected]>

Author: 3 people

android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/tezos/TestTezosSigner.kt

@@ -161,7 +161,7 @@ class TestTezosTransactionSigner {
         assertTrue(AnySigner.supportsJSON(TEZOS.value()))
         assertEquals(
             result,
-            "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200429a986c8072a40a1f3a3e2ab5a5819bb1b2fb69993c5004837815b9dc55923e6c0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80993f001f44e810201000081faa75f741ef614b0e35fcc8c90dfa3b0b957210001b86398d5b9be737dca8e4106ea18d70e69b75e92f892fb283546a99152b8d7794b919c0fbf1c31de386069a60014491c0e7505adef5781cead1cfe6608030b"
+            "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200429a986c8072a40a1f3a3e2ab5a5819bb1b2fb69993c5004837815b9dc55923e006c0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80993f001f44e810201000081faa75f741ef614b0e35fcc8c90dfa3b0b957210097e828f0ec91b827995ef3ee81aac244f39f9961f2b1479626e228a14b80e860ae1dd3818648222c4b6aebcd3c57de8acebd1640f35c498e900e61876b7ecf0a"
         )
     }
 }

src/Tezos/Forging.cpp

@@ -179,6 +179,7 @@ Data forgeOperation(const Proto::Operation& operation) {
         append(forged, forgedGasLimit);
         append(forged, forgedStorageLimit);
         append(forged, forgedPublicKey);
+        forged.push_back(0x00); // presence_of_proof = false (no proof for non-tz4)
         return forged;
     }
 

swift/Tests/Blockchains/TezosTests.swift

@@ -176,7 +176,7 @@ class TezosTests: XCTestCase {
         }
 
         let output: TezosSigningOutput = AnySigner.sign(input: input, coin: .tezos)
-        let expected = "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200311f002e899cdd9a52d96cb8be18ea2bbab867c505da2b44ce10906f511cff956c0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80993f001f44e810201000081faa75f741ef614b0e35fcc8c90dfa3b0b95721000217034271b815e5f0c0a881342838ce49d7b48cdf507c72b1568c69a10db70c98774cdad1a74df760763e25f760ff13afcbbf3a1f2c833a0beeb9576a579c05"
+        let expected = "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200311f002e899cdd9a52d96cb8be18ea2bbab867c505da2b44ce10906f511cff95006c0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80993f001f44e810201000081faa75f741ef614b0e35fcc8c90dfa3b0b9572100ca20897ea1fd0251b3bb4f9acfe948f579f9fd4767a28e9a437f30a1193d8cc66d7b8084da70d480fd08873a47e39e4e6155879fe679f7dd2e4643be68c74205"
 
         XCTAssertEqual(output.encoded.hexString, expected)
     }

tests/chains/Tezos/ForgingTests.cpp

@@ -226,7 +226,7 @@ TEST(TezosTransaction, forgeReveal) {
     revealOperation.set_kind(TW::Tezos::Proto::Operation::REVEAL);
     revealOperation.set_allocated_reveal_operation_data(revealOperationData);
 
-    auto expected = "6b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200429a986c8072a40a1f3a3e2ab5a5819bb1b2fb69993c5004837815b9dc55923e";
+    auto expected = "6b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200429a986c8072a40a1f3a3e2ab5a5819bb1b2fb69993c5004837815b9dc55923e00";
     auto serialized = forgeOperation(revealOperation);
 
     ASSERT_EQ(hex(serialized), expected);

tests/chains/Tezos/OperationListTests.cpp

@@ -63,7 +63,7 @@ TEST(TezosOperationList, ForgeOperationList_RevealOnly) {
     revealOperation.set_allocated_reveal_operation_data(revealOperationData);
 
     op_list.addOperation(revealOperation);
-    auto expected = "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200429a986c8072a40a1f3a3e2ab5a5819bb1b2fb69993c5004837815b9dc55923e";
+    auto expected = "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200429a986c8072a40a1f3a3e2ab5a5819bb1b2fb69993c5004837815b9dc55923e00";
     auto forged = op_list.forge(key);
 
     ASSERT_EQ(hex(forged), expected);
@@ -147,7 +147,7 @@ TEST(TezosOperationList, ForgeOperationList_TransactionAndReveal) {
     op_list.addOperation(revealOperation);
     op_list.addOperation(transactionOperation);
 
-    auto expected = "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b003e47f837f0467b4acde406ed5842f35e2414b1a8f80992f001f44e810200603247bbf52501498293686da89ad8b2aca85f83b90903d4521dd2aba66054eb6c003e47f837f0467b4acde406ed5842f35e2414b1a8f80993f001f44e8102010000e42504da69a7c8d5baeaaeebe157a02db6b22ed800";
+    auto expected = "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b003e47f837f0467b4acde406ed5842f35e2414b1a8f80992f001f44e810200603247bbf52501498293686da89ad8b2aca85f83b90903d4521dd2aba66054eb006c003e47f837f0467b4acde406ed5842f35e2414b1a8f80993f001f44e8102010000e42504da69a7c8d5baeaaeebe157a02db6b22ed800";
     auto forged = op_list.forge(key);
 
     ASSERT_EQ(hex(forged), expected);
@@ -171,7 +171,7 @@ TEST(TezosOperationList, ForgeOperationList_RevealWithoutPublicKey) {
 
     op_list.addOperation(revealOperation);
 
-    auto expected = "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b003e47f837f0467b4acde406ed5842f35e2414b1a8f80992f001f44e810200603247bbf52501498293686da89ad8b2aca85f83b90903d4521dd2aba66054eb";
+    auto expected = "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b003e47f837f0467b4acde406ed5842f35e2414b1a8f80992f001f44e810200603247bbf52501498293686da89ad8b2aca85f83b90903d4521dd2aba66054eb00";
     auto forged = op_list.forge(key);
 
     ASSERT_EQ(hex(forged), expected);

tests/chains/Tezos/SignerTests.cpp

@@ -80,7 +80,7 @@ TEST(TezosSigner, SignOperationList) {
     auto key = PrivateKey(Data(decodedPrivateKey.begin() + 4, decodedPrivateKey.end()), TWCurveED25519);
 
     std::string expectedForgedBytesToSign = hex(op_list.forge(key));
-    std::string expectedSignature = "871693145f2dc72861ff6816e7ac3ce93c57611ac09a4c657a5a35270fa57153334c14cd8cae94ee228b6ef52f0e3f10948721e666318bc54b6c455404b11e03";
+    std::string expectedSignature = "30c9471d2d270ad70c725b2869535b35efba1ddc17783359057a9b4ac97526ab8872c23dad2533e1eb608c9549956e10f59aeca0b4efb1fcbd4140dec4790b07";
     std::string expectedSignedBytes = expectedForgedBytesToSign + expectedSignature;
 
     auto signedBytes = Signer().signOperationList(key, op_list);

tests/chains/Tezos/TWAnySignerTests.cpp

@@ -3,6 +3,7 @@
 // Copyright © 2017 Trust Wallet.
 
 #include "HexCoding.h"
+#include "HDWallet.h"
 #include "Tezos/BinaryCoding.h"
 #include "proto/Tezos.pb.h"
 #include "TestUtilities.h"
@@ -125,7 +126,46 @@ TEST(TWAnySignerTezos, Sign) {
     Proto::SigningOutput output;
     ANY_SIGN(input, TWCoinTypeTezos);
 
-    EXPECT_EQ(hex(output.encoded()), "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200311f002e899cdd9a52d96cb8be18ea2bbab867c505da2b44ce10906f511cff956c0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80993f001f44e810201000081faa75f741ef614b0e35fcc8c90dfa3b0b95721000217034271b815e5f0c0a881342838ce49d7b48cdf507c72b1568c69a10db70c98774cdad1a74df760763e25f760ff13afcbbf3a1f2c833a0beeb9576a579c05");
+    EXPECT_EQ(hex(output.encoded()), "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200311f002e899cdd9a52d96cb8be18ea2bbab867c505da2b44ce10906f511cff95006c0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80993f001f44e810201000081faa75f741ef614b0e35fcc8c90dfa3b0b9572100ca20897ea1fd0251b3bb4f9acfe948f579f9fd4767a28e9a437f30a1193d8cc66d7b8084da70d480fd08873a47e39e4e6155879fe679f7dd2e4643be68c74205");
+}
+
+TEST(TWAnySignerTezos, SignMainnet) {
+    const auto wallet = HDWallet("hen betray system volcano excess wash viable joke elder boil goat cricket", "");
+    const auto privateKey = wallet.getKey(TWCoinTypeTezos, TWDerivationDefault);
+    const auto publicKey = privateKey.getPublicKey(TWPublicKeyTypeED25519);
+    const auto address = wallet.deriveAddress(TWCoinTypeTezos, TWDerivationDefault);
+
+    Proto::SigningInput input;
+    input.set_private_key(privateKey.bytes.data(), privateKey.bytes.size());
+    auto& operations = *input.mutable_operation_list();
+    operations.set_branch("BMWRrvZwJHmUhQEmGET9pshBJ2tTkqoQ8TF1vu78iaDTH98HL3H");
+
+    auto& reveal = *operations.add_operations();
+    auto& revealData = *reveal.mutable_reveal_operation_data();
+    revealData.set_public_key(publicKey.bytes.data(), publicKey.bytes.size());
+    reveal.set_source(address);
+    reveal.set_fee(1272);
+    reveal.set_counter(187815742);
+    reveal.set_gas_limit(10100);
+    reveal.set_storage_limit(257);
+    reveal.set_kind(Proto::Operation::REVEAL);
+
+    auto& transaction = *operations.add_operations();
+    auto& txData = *transaction.mutable_transaction_operation_data();
+    txData.set_amount(1);
+    txData.set_destination("tz1XVJ8bZUXs7r5NV8dHvuiBhzECvLRLR3jW");
+    transaction.set_source(address);
+    transaction.set_fee(1272);
+    transaction.set_counter(187815743);
+    transaction.set_gas_limit(10100);
+    transaction.set_storage_limit(257);
+    transaction.set_kind(Proto::Operation::TRANSACTION);
+
+    Proto::SigningOutput output;
+    ANY_SIGN(input, TWCoinTypeTezos);
+
+    // https://tzkt.io/oownY91ffLuq3ehdTmDy7rpvmFh2BYvmchKqzHcchoiEvcq4A25/187815742
+    EXPECT_EQ(hex(output.encoded()), "ec7a7f24aa912d8a52c6823a759e04957049ad70ae14d2b90f9bf92d1f3b8a326b00e1adcf685eeadda7d2552cd7d83e9ca07bf2793bf809beaec759f44e81020044ec60cb2d32d9b3f9087a46f18a2ff1bb9b9a798d7738b62ede87d1e721a624006c00e1adcf685eeadda7d2552cd7d83e9ca07bf2793bf809bfaec759f44e810201000081faa75f741ef614b0e35fcc8c90dfa3b0b95721000fc4263d2ba5ad2b4e770c86f50323726eefce1df5fc7b84cbe59cbb0cc9f583c37b3ee3e765a41b3e06101d75951864a22aea4c9c95ed23aed89eab2073bf03");
 }
 
 TEST(TWAnySignerTezos, SignJSON) {
@@ -134,7 +174,7 @@ TEST(TWAnySignerTezos, SignJSON) {
     auto result = WRAPS(TWAnySignerSignJSON(json.get(), key.get(), TWCoinTypeTezos));
 
     ASSERT_TRUE(TWAnySignerSupportsJSON(TWCoinTypeTezos));
-    assertStringsEqual(result, "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200429a986c8072a40a1f3a3e2ab5a5819bb1b2fb69993c5004837815b9dc55923e6c0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80993f001f44e810201000081faa75f741ef614b0e35fcc8c90dfa3b0b957210001b86398d5b9be737dca8e4106ea18d70e69b75e92f892fb283546a99152b8d7794b919c0fbf1c31de386069a60014491c0e7505adef5781cead1cfe6608030b");
+    assertStringsEqual(result, "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80992f001f44e810200429a986c8072a40a1f3a3e2ab5a5819bb1b2fb69993c5004837815b9dc55923e006c0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80993f001f44e810201000081faa75f741ef614b0e35fcc8c90dfa3b0b957210097e828f0ec91b827995ef3ee81aac244f39f9961f2b1479626e228a14b80e860ae1dd3818648222c4b6aebcd3c57de8acebd1640f35c498e900e61876b7ecf0a");
 }
 
 } // namespace TW::Tezos::tests

tests/chains/Tezos/TransactionCompilerTests.cpp

@@ -5,7 +5,6 @@
 #include "Coin.h"
 #include "HexCoding.h"
 #include "PrivateKey.h"
-#include "PublicKey.h"
 #include "TransactionCompiler.h"
 
 #include "proto/Tezos.pb.h"
@@ -18,20 +17,26 @@
 #include <gtest/gtest.h>
 
 using namespace TW;
+using namespace TW::Tezos;
 
 TEST(TezosCompiler, CompileWithSignatures) {
     const auto coin = TWCoinTypeTezos;
 
-    /// Step 1: Prepare transaction input (protobuf)
+    // Test key
     auto privateKey =
         PrivateKey(parse_hex("2e8905819b8723fe2c1d161860e5ee1830318dbf49a83bd451cfb8440c28bd6f"));
-    auto publicKey = privateKey.getPublicKey(::publicKeyType(coin));
-    auto revealKey = parse_hex("311f002e899cdd9a52d96cb8be18ea2bbab867c505da2b44ce10906f511cff95");
 
+    // This is the forged (non-base58) reveal public key bytes used in older golden vectors.
+    // It corresponds to edpk "edpku9ZF6UUAEo1AL3NWy1oxHLL6AfQcGYwA5hFKrEKVHMT3Xx889A"
+    auto revealKey = parse_hex(
+        "311f002e899cdd9a52d96cb8be18ea2bbab867c505da2b44ce10906f511cff95");
+
+    // -------- Step 1: Prepare transaction input (protobuf)
     TW::Tezos::Proto::SigningInput input;
     auto& operations = *input.mutable_operation_list();
     operations.set_branch("BL8euoCWqNCny9AR3AKjnpi38haYMxjei1ZqNHuXMn19JSQnoWp");
 
+    // REVEAL (must come before any other manager ops for the same source)
     auto& reveal = *operations.add_operations();
     auto& revealData = *reveal.mutable_reveal_operation_data();
     revealData.set_public_key(revealKey.data(), revealKey.size());
@@ -42,70 +47,82 @@ TEST(TezosCompiler, CompileWithSignatures) {
     reveal.set_storage_limit(257);
     reveal.set_kind(Tezos::Proto::Operation::REVEAL);
 
-    auto& transaction = *operations.add_operations();
-    auto& txData = *transaction.mutable_transaction_operation_data();
+    // TRANSACTION
+    auto& tx = *operations.add_operations();
+    auto& txData = *tx.mutable_transaction_operation_data();
     txData.set_amount(1);
     txData.set_destination("tz1XVJ8bZUXs7r5NV8dHvuiBhzECvLRLR3jW");
-    transaction.set_source("tz1XVJ8bZUXs7r5NV8dHvuiBhzECvLRLR3jW");
-    transaction.set_fee(1272);
-    transaction.set_counter(30739);
-    transaction.set_gas_limit(10100);
-    transaction.set_storage_limit(257);
-    transaction.set_kind(Tezos::Proto::Operation::TRANSACTION);
+    tx.set_source("tz1XVJ8bZUXs7r5NV8dHvuiBhzECvLRLR3jW");
+    tx.set_fee(1272);
+    tx.set_counter(30739);
+    tx.set_gas_limit(10100);
+    tx.set_storage_limit(257);
+    tx.set_kind(Tezos::Proto::Operation::TRANSACTION);
 
     auto inputString = input.SerializeAsString();
     auto inputStrData = TW::Data(inputString.begin(), inputString.end());
 
-    /// Step 2: Obtain preimage hash
+    // -------- Step 2: Obtain preimage hash
     const auto preImageHashData = TransactionCompiler::preImageHashes(coin, inputStrData);
 
-    auto preSigningOutput = TW::TxCompiler::Proto::PreSigningOutput();
-    ASSERT_TRUE(
-        preSigningOutput.ParseFromArray(preImageHashData.data(), (int)preImageHashData.size()));
+    TW::TxCompiler::Proto::PreSigningOutput preSigningOutput;
+    ASSERT_TRUE(preSigningOutput.ParseFromArray(preImageHashData.data(), (int)preImageHashData.size()));
     ASSERT_EQ(preSigningOutput.error(), Common::Proto::OK);
 
     auto preImageHash = preSigningOutput.data_hash();
+    // This expected hash should remain stable given the fixed inputs above.
     EXPECT_EQ(hex(preImageHash),
-              "12e4f8b17ad3b316a5a56960db76c7d6505dbf2fff66106be75c8d6753daac0e");
+              "2268aec5a2becbcd784a03060a4816e20396e6d96e7839ddaf2c3b980632e591");
+
+    // Produce a proper 64-byte Ed25519 signature (R||S) over the preimage hash.
+    Data digest(preImageHash.begin(), preImageHash.end());
+    auto signature = privateKey.sign(digest, TWCurveED25519);
+    ASSERT_EQ(signature.size(), 64ul);
 
-    auto signature = parse_hex("0217034271b815e5f0c0a881342838ce49d7b48cdf507c72b1568c69a10db70c987"
-                               "74cdad1a74df760763e25f760ff13afcbbf3a1f2c833a0beeb9576a579c05");
+    // -------- Step 3: Compile transaction using that signature
+    auto compiledData = TransactionCompiler::compileWithSignatures(coin, inputStrData, {signature}, {});
+    Proto::SigningOutput compiledOutput;
+    ASSERT_TRUE(compiledOutput.ParseFromArray(compiledData.data(), (int)compiledData.size()));
+    const auto compiledHex = hex(compiledOutput.encoded());
 
-    /// Step 3: Compile transaction info
-    const auto tx =
-        "3756ef37b1be849e3114643f0aa5847cabf9a896d3bfe4dd51448de68e91da016b0081faa75f741ef614b0e35f"
-        "cc8c90dfa3b0b95721f80992f001f44e810200311f002e899cdd9a52d96cb8be18ea2bbab867c505da2b44ce10"
-        "906f511cff956c0081faa75f741ef614b0e35fcc8c90dfa3b0b95721f80993f001f44e810201000081faa75f74"
-        "1ef614b0e35fcc8c90dfa3b0b95721000217034271b815e5f0c0a881342838ce49d7b48cdf507c72b1568c69a1"
-        "0db70c98774cdad1a74df760763e25f760ff13afcbbf3a1f2c833a0beeb9576a579c05";
-    auto outputData =
-        TransactionCompiler::compileWithSignatures(coin, inputStrData, {signature}, {});
+    // As a cross-check, sign the same input with AnySigner and compare full bytes.
+    TW::Tezos::Proto::SigningInput signingInput;
+    ASSERT_TRUE(signingInput.ParseFromArray(inputStrData.data(), (int)inputStrData.size()));
+    signingInput.set_private_key(privateKey.bytes.data(), privateKey.bytes.size());
 
     {
-        TW::Tezos::Proto::SigningOutput output;
-        ASSERT_TRUE(output.ParseFromArray(outputData.data(), (int)outputData.size()));
+        Proto::SigningOutput output;
+        ANY_SIGN(signingInput, coin);
+        const auto anySignHex = hex(output.encoded());
 
-        EXPECT_EQ(hex(output.encoded()), tx);
+        ASSERT_EQ(compiledHex, anySignHex);
     }
 
-    { // Double check: check if simple signature process gives the same result. Note that private
-      // keys were not used anywhere up to this point.
-        TW::Tezos::Proto::SigningInput signingInput;
-        ASSERT_TRUE(signingInput.ParseFromArray(inputStrData.data(), (int)inputStrData.size()));
-        signingInput.set_private_key(privateKey.bytes.data(), privateKey.bytes.size());
+    // -------- Structural Seoul check:
+    // Ensure the reveal has the new presence_of_proof byte (0x00) after the forged public key,
+    // followed by the transaction op tag (0x6c).
+    {
+        // Reveal tag = 0x6b, Transaction tag = 0x6c
+        ASSERT_NE(compiledHex.find("6b"), std::string::npos) << "Reveal tag not found";
 
-        TW::Tezos::Proto::SigningOutput output;
-        ANY_SIGN(signingInput, coin);
+        const std::string forgedPubKeyHex = hex(revealKey); // already raw forged key bytes
+        auto pkPos = compiledHex.find(forgedPubKeyHex);
+        ASSERT_NE(pkPos, std::string::npos) << "Forged public key not found in reveal";
+
+        // presence_of_proof = 0x00 must be immediately after the public key bytes
+        ASSERT_EQ(compiledHex.substr(pkPos + forgedPubKeyHex.size(), 2), "00");
 
-        ASSERT_EQ(hex(output.encoded()), tx);
+        // and the next op tag should be 0x6c (transaction)
+        ASSERT_EQ(compiledHex.substr(pkPos + forgedPubKeyHex.size() + 2, 2), "6c");
     }
 
-    { // Negative: inconsistent signatures & publicKeys
-        outputData = TransactionCompiler::compileWithSignatures(
+    // -------- Negative: inconsistent signatures & public keys count
+    {
+        auto compiledBad = TransactionCompiler::compileWithSignatures(
             coin, inputStrData, {signature, signature}, {});
-        Tezos::Proto::SigningOutput output;
-        ASSERT_TRUE(output.ParseFromArray(outputData.data(), (int)outputData.size()));
-        EXPECT_EQ(output.encoded().size(), 0ul);
-        EXPECT_EQ(output.error(), Common::Proto::Error_signatures_count);
+        Proto::SigningOutput badOutput;
+        ASSERT_TRUE(badOutput.ParseFromArray(compiledBad.data(), (int)compiledBad.size()));
+        EXPECT_EQ(badOutput.encoded().size(), 0ul);
+        EXPECT_EQ(badOutput.error(), Common::Proto::Error_signatures_count);
     }
-}
+}