Rewording some logs and comments

nathanieliov · nathanieliov · commit d0419f8190bd · 2024-04-16T00:36:47.000-04:00
diff --git a/src/main/java/co/rsk/federate/btcreleaseclient/BtcPegoutClient.java b/src/main/java/co/rsk/federate/btcreleaseclient/BtcPegoutClient.java
@@ -216,8 +216,8 @@ public void onBlock(org.ethereum.core.Block block, List<TransactionReceipt> rece
             if (!isPegoutEnabled || nodeBlockProcessor.hasBetterBlockToSync()) {
                 return;
             }
-            // Pegout must be processed on an every-single-block basis,
-            // since otherwise we could be missing pegout potentially mined
+            // Pegout events must be processed on an every-single-block basis,
+            // since otherwise we could be missing pegouts potentially mined
             // on what originally were side-chains and then turned into best-chains.
             Stream<LogInfo> transactionLogs = receipts.stream().map(TransactionReceipt::getLogInfoList).flatMap(Collection::stream);
             Stream<LogInfo> bridgeLogs = transactionLogs.filter(info -> Arrays.equals(info.getAddress(), PrecompiledContracts.BRIDGE_ADDR.getBytes()));
@@ -248,7 +248,7 @@ private BtcTransaction convertToBtcTxFromSolidityData(byte[] dataFromBtcReleaseT
 
     protected void processPegouts(Set<Map.Entry<Keccak256, BtcTransaction>> pegouts) {
         try {
-            logger.debug("[processPegout] Starting process with {} pegouts", pegouts.size());
+            logger.debug("[processPegouts] Starting process with {} pegouts", pegouts.size());
             int version = signer.getVersionForKeyId(BTC_KEY_ID.getKeyId());
             // Get pegout information and store it in a new list
             List<PegoutCreationInformation> pegoutsReadyToSign = new ArrayList<>();
@@ -257,7 +257,7 @@ protected void processPegouts(Set<Map.Entry<Keccak256, BtcTransaction>> pegouts)
                 tryGetPegoutInformation(version, pegout.getKey(), pegoutBtcTx)
                     .ifPresent(pegoutsReadyToSign::add);
             }
-            logger.debug("[processPegout] Going to sign {} pegouts", pegoutsReadyToSign.size());
+            logger.debug("[processPegouts] Going to sign {} pegouts", pegoutsReadyToSign.size());
             // TODO: Sorting and then looping again is not efficient but we are making a compromise on performance here as we don't have that many pegouts
             // Sort descending
             pegoutsReadyToSign.sort((a, b) -> (int) (b.getPegoutCreationRskBlock().getNumber() - a.getPegoutCreationRskBlock().getNumber()));
@@ -266,9 +266,9 @@ protected void processPegouts(Set<Map.Entry<Keccak256, BtcTransaction>> pegouts)
                 signConfirmedPegout(version, pegoutsReadyToSign.get(0));
             }
         } catch (Exception e) {
-            logger.error("[processPegout] There was an error trying to process pegouts", e);
+            logger.error("[processPegouts] There was an error trying to process pegouts", e);
         }
-        logger.trace("[processPegout] Finished processing pegouts");
+        logger.trace("[processPegouts] Finished processing pegouts");
     }
 
     protected Optional<PegoutCreationInformation> tryGetPegoutInformation(
@@ -278,19 +278,19 @@ protected Optional<PegoutCreationInformation> tryGetPegoutInformation(
     ) {
         try {
             // Discard transactions this fed already signed or cannot be signed by the observed federations
-            logger.trace("[tryGetPegoutInformation] Validating if pegout btcTxHash {} can be signed by observed federations and " +
+            logger.trace("[tryGetPegoutInformation] Validating if pegoutBtcTxHash {} can be signed by observed federations and " +
                     "that it is not already signed by current fed", pegoutBtcTx.getHash());
-            validateConfirmedPegoutCanBeSigned(pegoutBtcTx);
+            validatePegoutBtcTxCanBeSigned(pegoutBtcTx);
 
             // IMPORTANT: As per the current behaviour of the bridge, no pegout should have inputs to be signed
             // by different federations. Taking this into account, when removing the signatures from the tx new
             // scriptSigs are created that all spend from the same federation
             logger.trace("[tryGetPegoutInformation] Removing possible signatures from pegout btcTxHash {}", pegoutBtcTx.getHash());
             Federation spendingFed = getSpendingFederation(pegoutBtcTx);
-            removeSignaturesFromPegoutBtxTx(pegoutBtcTx, spendingFed);
+            removeSignaturesFromPegoutBtcTx(pegoutBtcTx, spendingFed);
             logger.trace("[tryGetPegoutInformation] pegout btcTxHash without signatures {}", pegoutBtcTx.getHash());
 
-            logger.trace("[tryGetPegoutInformation] Is tx in storage? {}", storageAccessor.hasBtcTxHash(pegoutBtcTx.getHash()));
+            logger.trace("[tryGetPegoutInformation] Is pegout btc tx in storage? {}", storageAccessor.hasBtcTxHash(pegoutBtcTx.getHash()));
             // Try to get the pegoutCreationRskTxHash from the map in memory, and if not found then use pegoutConfirmationRskTxHash
             Keccak256 pegoutCreationRskTxHash = storageAccessor.hasBtcTxHash(pegoutBtcTx.getHash()) ?
                 storageAccessor.getRskTxHash(pegoutBtcTx.getHash()) :
@@ -319,18 +319,18 @@ protected Optional<PegoutCreationInformation> tryGetPegoutInformation(
         return Optional.empty();
     }
 
-    protected void validateConfirmedPegoutCanBeSigned(BtcTransaction pegoutBtcTx) throws FederatorAlreadySignedException, FederationCantSignException {
+    protected void validatePegoutBtcTxCanBeSigned(BtcTransaction pegoutBtcTx) throws FederatorAlreadySignedException, FederationCantSignException {
         try {
             BtcECKey federatorPublicKey = signer.getPublicKey(BTC_KEY_ID.getKeyId()).toBtcKey();
-            logger.trace("[validateConfirmedPegoutCanBeSigned] Federator public key {}", federatorPublicKey);
+            logger.trace("[validatePegoutBtcTxCanBeSigned] Federator public key {}", federatorPublicKey);
 
             for (int inputIndex = 0; inputIndex < pegoutBtcTx.getInputs().size(); inputIndex++) {
                 TransactionInput txIn = pegoutBtcTx.getInput(inputIndex);
                 Script redeemScript = getRedeemScriptFromInput(txIn);
                 Script standardRedeemScript = extractStandardRedeemScript(redeemScript);
 
                 // Check if input is not already signed by the current federator
-                logger.trace("[validateConfirmedPegoutCanBeSigned] Checking if the input {} is not already signed by the current federator", inputIndex);
+                logger.trace("[validatePegoutBtcTxCanBeSigned] Checking if the input {} is not already signed by the current federator", inputIndex);
                 co.rsk.bitcoinj.core.Sha256Hash sigHash = pegoutBtcTx.hashForSignature(
                         inputIndex,
                         redeemScript,
@@ -348,12 +348,12 @@ protected void validateConfirmedPegoutCanBeSigned(BtcTransaction pegoutBtcTx) th
                 }
 
                 // Check if any of the observed federations can sign the tx
-                logger.trace("[validateConfirmedPegoutCanBeSigned] Checking if any of the observed federations can sign the pegout btc tx input {}", inputIndex);
+                logger.trace("[validatePegoutBtcTxCanBeSigned] Checking if any of the observed federations can sign the pegout btc tx input {}", inputIndex);
                 observedFederations.stream()
-                        .forEach(f -> logger.trace("[validateConfirmedPegoutCanBeSigned] federation p2sh redeem script {}", f.getRedeemScript()));
+                        .forEach(f -> logger.trace("[validatePegoutBtcTxCanBeSigned] federation p2sh redeem script {}", f.getRedeemScript()));
                 List<Federation> spendingFedFilter = observedFederations.stream()
                         .filter(f -> (extractDefaultRedeemScript(f)).equals(standardRedeemScript)).collect(Collectors.toList());
-                logger.debug("[validateConfirmedPegoutCanBeSigned] spendingFedFilter size {}", spendingFedFilter.size());
+                logger.debug("[validatePegoutBtcTxCanBeSigned] spendingFedFilter size {}", spendingFedFilter.size());
                 if (spendingFedFilter.isEmpty()) {
                     String message = String.format(
                             "PegoutBtcTxHash %s can't be signed by any of the observed federations",
@@ -363,7 +363,7 @@ protected void validateConfirmedPegoutCanBeSigned(BtcTransaction pegoutBtcTx) th
                 }
             }
         } catch (SignerException e) {
-            String message = String.format("[validateConfirmedPegoutCanBeSigned] Error validating pegoutBtcTxHash %s, " +
+            String message = String.format("[validatePegoutBtcTxCanBeSigned] Error validating pegoutBtcTxHash %s, " +
                     "failed to get current federator public key", pegoutBtcTx.getHashAsString());
             logger.error(message, e);
         }
@@ -434,16 +434,16 @@ public void onBroadcastingSignedPegout(BtcTransaction signedBtcTx) {
     Received pegoutBtcTx inputs are replaced by base inputs without signatures that spend from the given federation.
     This way the pegoutBtcTx has the same hash as the one registered in release_requested event topics.
      */
-    protected void removeSignaturesFromPegoutBtxTx(BtcTransaction pegoutBtcTx, Federation spendingFed) {
+    protected void removeSignaturesFromPegoutBtcTx(BtcTransaction pegoutBtcTx, Federation spendingFed) {
         for (int inputIndex = 0; inputIndex < pegoutBtcTx.getInputs().size(); inputIndex++) {
             //Get redeem script for current input
             TransactionInput txInput = pegoutBtcTx.getInput(inputIndex);
             Script inputRedeemScript = getRedeemScriptFromInput(txInput);
-            logger.trace("[removeSignaturesFromPegoutBtxTx] input {} scriptSig {}", inputIndex, pegoutBtcTx.getInput(inputIndex).getScriptSig());
-            logger.trace("[removeSignaturesFromPegoutBtxTx] input {} redeem script {}", inputIndex, inputRedeemScript);
+            logger.trace("[removeSignaturesFromPegoutBtcTx] input {} scriptSig {}", inputIndex, pegoutBtcTx.getInput(inputIndex).getScriptSig());
+            logger.trace("[removeSignaturesFromPegoutBtcTx] input {} redeem script {}", inputIndex, inputRedeemScript);
 
             txInput.setScriptSig(createBaseInputScriptThatSpendsFromTheFederation(spendingFed, inputRedeemScript));
-            logger.debug("[removeSignaturesFromPegoutBtxTx] Updated input {} scriptSig with base input script that " +
+            logger.debug("[removeSignaturesFromPegoutBtcTx] Updated input {} scriptSig with base input script that " +
                     "spends from the federation {}", inputIndex, spendingFed.getAddress());
         }
     }
diff --git a/src/main/java/co/rsk/federate/btcreleaseclient/BtcPegoutClientStorageSynchronizer.java b/src/main/java/co/rsk/federate/btcreleaseclient/BtcPegoutClientStorageSynchronizer.java
@@ -106,7 +106,14 @@ private void sync() {
                 return;
             }
 
-            Block fromBlock = findBlockToSearch(storageBestBlock);
+            Block fromBlock;
+            /* If there is no data in the file, set a limit to avoid looking up all the blockchain */
+            if (storageBestBlock == null) {
+                long lastBlockNumberToSearch = blockStore.getBestBlock().getNumber() - this.maxInitializationDepth;
+                fromBlock = blockStore.getChainBlockByNumber(Math.max(lastBlockNumberToSearch, 0));
+            } else {
+                fromBlock = blockStore.getChainBlockByNumber(storageBestBlock.getNumber() + 1);
+            }
 
             logger.info(
                 "[sync] going to sync from block {} ({})",
@@ -152,16 +159,6 @@ private boolean isStorageSync(Block storageBestBlock) {
         return false;
     }
 
-    private Block findBlockToSearch(Block storageBestBlock) {
-        /* If there is no data in the file, set a limit to avoid looking up all the blockchain */
-        if (storageBestBlock == null) {
-            long lastBlockNumberToSearch = blockStore.getBestBlock().getNumber() - this.maxInitializationDepth;
-            return blockStore.getChainBlockByNumber(Math.max(lastBlockNumberToSearch, 0));
-        } else {
-            return blockStore.getChainBlockByNumber(storageBestBlock.getNumber() + 1);
-        }
-    }
-
     private Block getStorageBestBlock(Keccak256 storageBestBlockHash) {
         Block storageBestBlock = blockStore.getBlockByHash(storageBestBlockHash.getBytes());
         if (storageBestBlock == null) {
diff --git a/src/main/java/co/rsk/federate/io/btcreleaseclientstorage/BtcPegoutClientFileStorageImpl.java b/src/main/java/co/rsk/federate/io/btcreleaseclientstorage/BtcPegoutClientFileStorageImpl.java
@@ -91,7 +91,7 @@ private BtcPegoutClientFileReadResult readFromRlp(byte[] fileData) {
                 }
             }
         } catch (Exception e) {
-            logger.error("[readFromRlp] error trying to file data.", e);
+            logger.error("[readFromRlp] error trying to read file data.", e);
             return new BtcPegoutClientFileReadResult(Boolean.FALSE, null);
         }
 
diff --git a/src/test/java/co/rsk/federate/btcreleaseclient/BtcPegoutClientTest.java b/src/test/java/co/rsk/federate/btcreleaseclient/BtcPegoutClientTest.java
@@ -558,7 +558,7 @@ void onBlock_return_when_pegout_is_disabled() {
     }
 
     @Test
-    void validateConfirmedPegoutCanBeSigned_ok() throws Exception {
+    void validatePegoutBtcTxCanBeSigned_ok() throws Exception {
         // Arrange
         Federation federation = TestUtils.createFederation(params, 1);
 
@@ -574,7 +574,7 @@ void validateConfirmedPegoutCanBeSigned_ok() throws Exception {
     }
 
     @Test
-    void validateConfirmedPegoutCanBeSigned_fast_bridge_ok() throws Exception {
+    void validatePegoutBtcTxCanBeSigned_fast_bridge_ok() throws Exception {
         // Create a StandardMultisigFederation
         Federation federation = TestUtils.createFederation(params, 1);
 
@@ -594,7 +594,7 @@ void validateConfirmedPegoutCanBeSigned_fast_bridge_ok() throws Exception {
     }
 
     @Test
-    void validateConfirmedPegoutCanBeSigned_erp_fed_ok() throws Exception {
+    void validatePegoutBtcTxCanBeSigned_erp_fed_ok() throws Exception {
         Federation federation = TestUtils.createFederation(params, 3);
         FederationArgs federationArgs = federation.getArgs();
         ErpFederation nonStandardErpFederation =
@@ -610,7 +610,7 @@ void validateConfirmedPegoutCanBeSigned_erp_fed_ok() throws Exception {
     }
 
     @Test
-    void validateConfirmedPegoutCanBeSigned_federatorAlreadySigned() throws Exception {
+    void validatePegoutBtcTxCanBeSigned_federatorAlreadySigned() throws Exception {
         // Arrange
         BtcECKey federator1PrivKey = new BtcECKey();
         BtcECKey federator2PrivKey = new BtcECKey();
@@ -664,11 +664,11 @@ void validateConfirmedPegoutCanBeSigned_federatorAlreadySigned() throws Exceptio
         client.start(federation);
 
         // Act
-        assertThrows(FederatorAlreadySignedException.class, () -> client.validateConfirmedPegoutCanBeSigned(pegoutBtcTx));
+        assertThrows(FederatorAlreadySignedException.class, () -> client.validatePegoutBtcTxCanBeSigned(pegoutBtcTx));
     }
 
     @Test
-    void validateConfirmedPegoutCanBeSigned_federationCantSign() throws Exception {
+    void validatePegoutBtcTxCanBeSigned_federationCantSign() throws Exception {
         // Arrange
         Federation federation = TestUtils.createFederation(params, 1);
 
@@ -702,7 +702,7 @@ void validateConfirmedPegoutCanBeSigned_federationCantSign() throws Exception {
         );
 
         // Act
-        assertThrows(FederationCantSignException.class, () -> client.validateConfirmedPegoutCanBeSigned(pegoutBtcTx));
+        assertThrows(FederationCantSignException.class, () -> client.validatePegoutBtcTxCanBeSigned(pegoutBtcTx));
     }
 
     @Test
@@ -751,7 +751,7 @@ void removeSignaturesFromTransaction() {
         Sha256Hash signedTxHash = pegoutBtcTx.getHash();
 
         // Act
-        client.removeSignaturesFromPegoutBtxTx(pegoutBtcTx, federation);
+        client.removeSignaturesFromPegoutBtcTx(pegoutBtcTx, federation);
         Sha256Hash removedSignaturesTxHash = pegoutBtcTx.getHash();
 
         // Assert
@@ -838,7 +838,7 @@ private void test_validatePegoutBtcTxCanBeSigned(
         client.start(federation);
 
         // Act
-        client.validateConfirmedPegoutCanBeSigned(pegoutBtcTx);
+        client.validatePegoutBtcTxCanBeSigned(pegoutBtcTx);
     }
 
     private void test_extractStandardRedeemScript(

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ private BtcPegoutClientFileReadResult readFromRlp(byte[] fileData) {`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`	`} catch (Exception e) {`
`94`		`- logger.error("[readFromRlp] error trying to file data.", e);`
	`94`	`+ logger.error("[readFromRlp] error trying to read file data.", e);`
`95`	`95`	`return new BtcPegoutClientFileReadResult(Boolean.FALSE, null);`
`96`	`96`	`}`
`97`	`97`