refactor: verifyTransaction method (#2661)

Signed-off-by: Mustafa Uzun <mustafa.uzun@limechain.tech>

Author: mustafauzunn

sdk/src/main/java/com/hedera/hashgraph/sdk/PublicKey.java

@@ -169,12 +169,6 @@ public boolean verifyTransaction(Transaction<?> transaction) {
             transaction.freeze();
         }
 
-        for (var publicKey : transaction.publicKeys) {
-            if (publicKey.equals(this)) {
-                return true;
-            }
-        }
-
         for (var signedTransaction : transaction.innerSignedTransactions) {
             var found = false;
 

sdk/src/main/java/com/hedera/hashgraph/sdk/Transaction.java

@@ -1129,6 +1129,7 @@ public T addSignature(PublicKey publicKey, byte[] signature) {
         publicKeys.add(publicKey);
         signers.add(null);
         sigPairLists.get(0).addSigPair(publicKey.toSignaturePairProtobuf(signature));
+        innerSignedTransactions.get(0).setSigMap(sigPairLists.get(0));
 
         // noinspection unchecked
         return (T) this;
@@ -1747,6 +1748,7 @@ private boolean addSignatureIfNotExists(int index, PublicKey publicKey, byte[] s
         // Add the signature to the signature map
         SignaturePair newSigPair = publicKey.toSignaturePairProtobuf(signature);
         sigMapBuilder.addSigPair(newSigPair);
+        innerSignedTransactions.get(index).setSigMap(sigMapBuilder);
 
         return true;
     }

sdk/src/test/java/com/hedera/hashgraph/sdk/MockingTest.java

@@ -306,8 +306,6 @@ void accountInfoFlowFunctions() throws Throwable {
                 .setNodeAccountIds(List.of(AccountId.fromString("0.0.3")))
                 .freeze();
 
-        var properlySignedTx = makeTx.get().sign(privateKey);
-        var improperlySignedTx = makeTx.get().sign(otherPrivateKey);
         var properBigBytesSignature = privateKey.sign(BIG_BYTES);
         var improperBigBytesSignature = otherPrivateKey.sign(BIG_BYTES);
 
@@ -331,28 +329,19 @@ void accountInfoFlowFunctions() throws Throwable {
                     .build()));
         }
 
-        Assertions.assertTrue(AccountInfoFlow.verifyTransactionSignature(server.client, accountId, properlySignedTx));
-        Assertions.assertFalse(
-                AccountInfoFlow.verifyTransactionSignature(server.client, accountId, improperlySignedTx));
         Assertions.assertTrue(
                 AccountInfoFlow.verifySignature(server.client, accountId, BIG_BYTES, properBigBytesSignature));
         Assertions.assertFalse(
                 AccountInfoFlow.verifySignature(server.client, accountId, BIG_BYTES, improperBigBytesSignature));
-        Assertions.assertTrue(
-                AccountInfoFlow.verifyTransactionSignatureAsync(server.client, accountId, properlySignedTx)
-                        .get());
-        Assertions.assertFalse(
-                AccountInfoFlow.verifyTransactionSignatureAsync(server.client, accountId, improperlySignedTx)
-                        .get());
         Assertions.assertTrue(
                 AccountInfoFlow.verifySignatureAsync(server.client, accountId, BIG_BYTES, properBigBytesSignature)
                         .get());
         Assertions.assertFalse(
                 AccountInfoFlow.verifySignatureAsync(server.client, accountId, BIG_BYTES, improperBigBytesSignature)
                         .get());
 
-        Assertions.assertEquals(16, cryptoService.buffer.queryRequestsReceived.size());
-        for (int i = 0; i < 16; i += 2) {
+        Assertions.assertEquals(8, cryptoService.buffer.queryRequestsReceived.size());
+        for (int i = 0; i < 8; i += 2) {
             var costQueryRequest = cryptoService.buffer.queryRequestsReceived.get(i);
             var queryRequest = cryptoService.buffer.queryRequestsReceived.get(i + 1);
 
@@ -370,6 +359,60 @@ void accountInfoFlowFunctions() throws Throwable {
         server.close();
     }
 
+    @Test
+    void testVerifyTransactionFail() throws InvalidProtocolBufferException {
+        var key = PrivateKey.generateED25519();
+        var bogusSignature = new byte[64];
+
+        var serialized = new TokenMintTransaction()
+                .setTokenId(TokenId.fromString("1.2.3"))
+                .setAmount(5)
+                .setTransactionId(TransactionId.generate(AccountId.fromString("1.2.4")))
+                .setNodeAccountIds(List.of(AccountId.fromString("0.0.3")))
+                .freeze()
+                .addSignature(key.getPublicKey(), bogusSignature)
+                .toBytes();
+
+        var signedTransaction = SignedTransaction.parseFrom(
+                com.hedera.hashgraph.sdk.proto.Transaction.parseFrom(serialized).getSignedTransactionBytes());
+        com.hedera.hashgraph.sdk.Transaction<?> roundTrip = com.hedera.hashgraph.sdk.Transaction.fromBytes(serialized);
+
+        boolean rawVerify =
+                key.getPublicKey().verify(signedTransaction.getBodyBytes().toByteArray(), bogusSignature);
+        boolean txVerify = key.getPublicKey().verifyTransaction(roundTrip);
+
+        Assertions.assertFalse(rawVerify);
+        Assertions.assertFalse(txVerify);
+    }
+
+    @Test
+    void testVerifyTransactionFailSpecificNode() throws InvalidProtocolBufferException {
+        var key = PrivateKey.generateED25519();
+        var bogusSignature = new byte[64];
+        TransactionId transactionId = TransactionId.generate(AccountId.fromString("1.2.4"));
+        List<AccountId> nodeId = List.of(AccountId.fromString("0.0.3"));
+
+        var serialized = new TokenMintTransaction()
+                .setTokenId(TokenId.fromString("1.2.3"))
+                .setAmount(5)
+                .setTransactionId(transactionId)
+                .setNodeAccountIds(nodeId)
+                .freeze()
+                .addSignature(key.getPublicKey(), bogusSignature, transactionId, nodeId.getFirst())
+                .toBytes();
+
+        var signedTransaction = SignedTransaction.parseFrom(
+                com.hedera.hashgraph.sdk.proto.Transaction.parseFrom(serialized).getSignedTransactionBytes());
+        com.hedera.hashgraph.sdk.Transaction<?> roundTrip = com.hedera.hashgraph.sdk.Transaction.fromBytes(serialized);
+
+        boolean rawVerify =
+                key.getPublicKey().verify(signedTransaction.getBodyBytes().toByteArray(), bogusSignature);
+        boolean txVerify = key.getPublicKey().verifyTransaction(roundTrip);
+
+        Assertions.assertFalse(rawVerify);
+        Assertions.assertFalse(txVerify);
+    }
+
     @Test
     void exitOnAborted() throws PrecheckStatusException, TimeoutException, InterruptedException {
         List<Object> responses1 = List.of();

sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountInfoIntegrationTest.java

@@ -120,6 +120,8 @@ void accountInfoFlowVerifyFunctions() throws Throwable {
                     .setInitialBalance(Hbar.fromTinybars(1000))
                     .freezeWith(testEnv.client);
 
+            signedTx.execute(testEnv.client);
+
             assertThat(AccountInfoFlow.verifyTransactionSignature(testEnv.client, testEnv.operatorId, signedTx))
                     .isTrue();
             assertThat(AccountInfoFlow.verifyTransactionSignature(testEnv.client, testEnv.operatorId, unsignedTx))