Save the entire svp fund tx instead of only its hash

rskj-core/src/main/java/co/rsk/peg/BridgeSerializationUtils.java

@@ -18,6 +18,8 @@
 
 package co.rsk.peg;
 
+import static co.rsk.peg.federation.FederationFormatVersion.*;
+
 import co.rsk.bitcoinj.core.*;
 import co.rsk.bitcoinj.script.Script;
 import co.rsk.core.RskAddress;
@@ -37,7 +39,6 @@
 import org.ethereum.util.RLP;
 import org.ethereum.util.RLPElement;
 import org.ethereum.util.RLPList;
-
 import javax.annotation.Nullable;
 import java.io.*;
 import java.math.BigInteger;
@@ -46,12 +47,11 @@
 import java.util.*;
 import java.util.stream.Collectors;
 
-import static co.rsk.peg.federation.FederationFormatVersion.*;
-
 /**
  * Created by mario on 20/04/17.
  */
 public class BridgeSerializationUtils {
+
     private static final int FEDERATION_RLP_LIST_SIZE = 3;
     private static final int FEDERATION_CREATION_TIME_INDEX = 0;
     private static final int FEDERATION_CREATION_BLOCK_NUMBER_INDEX = 1;
@@ -61,45 +61,138 @@ private BridgeSerializationUtils() {
         throw new IllegalAccessError("Utility class, do not instantiate it");
     }
 
-    public static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map) {
-        int ntxs = map.size();
+    private static byte[] serializeRskTxHash(Keccak256 rskTxHash) {
+        return RLP.encodeElement(rskTxHash.getBytes());
+    }
+
+    private static Keccak256 deserializeRskTxHashFromHashData(byte[] hashBytes) {
+        return new Keccak256(hashBytes);
+    }
+
+    public static byte[] serializeBtcTransaction(BtcTransaction btcTransaction) {
+        return RLP.encodeElement(btcTransaction.bitcoinSerialize());
+    }
+
+    public static BtcTransaction deserializeBtcTransactionWithInputs(byte[] serializedTx, NetworkParameters networkParameters) {
+        return deserializeBtcTransaction(serializedTx, networkParameters, true);
+    }
+
+    public static BtcTransaction deserializeBtcTransactionWithoutInputs(byte[] serializedTx, NetworkParameters networkParameters) {
+        return deserializeBtcTransaction(serializedTx, networkParameters, false);
+    }
+
+    private static BtcTransaction deserializeBtcTransaction(
+        byte[] serializedTx,
+        NetworkParameters networkParameters,
+        boolean txHasInputs) {
+
+        if (serializedTx == null || serializedTx.length == 0) {
+            return null;
+        }
+
+        RLPElement rawTxElement = RLP.decode2(serializedTx).get(0);
+        byte[] rawTx = rawTxElement.getRLPData();
+
+        return deserializeBtcTransactionFromRawTx(rawTx, networkParameters, txHasInputs);
+    }
+
+    private static BtcTransaction deserializeBtcTransactionWithInputsFromRawTx(byte[] rawTx, NetworkParameters networkParameters) {
+        return deserializeBtcTransactionFromRawTx(rawTx, networkParameters, true);
+    }
+
+    private static BtcTransaction deserializeBtcTransactionFromRawTx(
+        byte[] rawTx,
+        NetworkParameters networkParameters,
+        boolean txHasInputs) {
+
+        if (!txHasInputs) {
+            BtcTransaction tx = new BtcTransaction(networkParameters);
+            tx.parseNoInputs(rawTx);
+            return tx;
+        }
+
+        return new BtcTransaction(networkParameters, rawTx);
+    }
+
+    public static byte[] serializeRskTxWaitingForSignatures(
+          Map.Entry<Keccak256, BtcTransaction> rskTxWaitingForSignaturesEntry) {
+        byte[][] serializedRskTxWaitingForSignaturesEntry =
+            serializeRskTxWaitingForSignaturesEntry(rskTxWaitingForSignaturesEntry);
+        return RLP.encodeList(serializedRskTxWaitingForSignaturesEntry);
+    }
+
+    public static byte[] serializeRskTxsWaitingForSignatures(
+          SortedMap<Keccak256, BtcTransaction> rskTxWaitingForSignaturesMap) {
+
+        int numberOfRskTxsWaitingForSignatures = rskTxWaitingForSignaturesMap.size();
+        byte[][] serializedRskTxWaitingForSignaturesMap = new byte[numberOfRskTxsWaitingForSignatures * 2][];
 
-        byte[][] bytes = new byte[ntxs * 2][];
         int n = 0;
+        for (Map.Entry<Keccak256, BtcTransaction> rskTxWaitingForSignaturesEntry : rskTxWaitingForSignaturesMap.entrySet()) {
+            byte[][] serializedRskTxWaitingForSignaturesEntry = serializeRskTxWaitingForSignaturesEntry(rskTxWaitingForSignaturesEntry);
+            serializedRskTxWaitingForSignaturesMap[n++] = serializedRskTxWaitingForSignaturesEntry[0];
+            serializedRskTxWaitingForSignaturesMap[n++] = serializedRskTxWaitingForSignaturesEntry[1];
+        }
+
+        return RLP.encodeList(serializedRskTxWaitingForSignaturesMap);
+    }
+
+    private static byte[][] serializeRskTxWaitingForSignaturesEntry(
+          Map.Entry<Keccak256, BtcTransaction> rskTxWaitingForSignaturesEntry) {
+
+        byte[] serializedRskTxWaitingForSignaturesEntryKey =
+            serializeRskTxHash(rskTxWaitingForSignaturesEntry.getKey());
+        byte[] serializedRskTxWaitingForSignaturesEntryValue =
+            serializeBtcTransaction(rskTxWaitingForSignaturesEntry.getValue());
 
-        for (Map.Entry<Keccak256, BtcTransaction> entry : map.entrySet()) {
-            bytes[n++] = RLP.encodeElement(entry.getKey().getBytes());
-            bytes[n++] = RLP.encodeElement(entry.getValue().bitcoinSerialize());
+        return new byte[][] { serializedRskTxWaitingForSignaturesEntryKey, serializedRskTxWaitingForSignaturesEntryValue };
+    }
+
+    public static Map.Entry<Keccak256, BtcTransaction> deserializeRskTxWaitingForSignatures(
+            byte[] data, NetworkParameters networkParameters) {
+
+        if (data == null || data.length == 0) {
+            return new AbstractMap.SimpleEntry<>(null, null);
         }
 
-        return RLP.encodeList(bytes);
+        RLPList rlpList = (RLPList) RLP.decode2(data).get(0);
+        return deserializeRskTxWaitingForSignaturesEntry(rlpList, 0, networkParameters);
     }
 
-    public static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs) {
-        SortedMap<Keccak256, BtcTransaction> map = new TreeMap<>();
+    public static SortedMap<Keccak256, BtcTransaction> deserializeRskTxsWaitingForSignatures(
+            byte[] data, NetworkParameters networkParameters) {
+
+        SortedMap<Keccak256, BtcTransaction> rskTxsWaitingForSignaturesMap = new TreeMap<>();
 
         if (data == null || data.length == 0) {
-            return map;
+            return rskTxsWaitingForSignaturesMap;
         }
 
-        RLPList rlpList = (RLPList)RLP.decode2(data).get(0);
+        RLPList rlpList = (RLPList) RLP.decode2(data).get(0);
+        int numberOfRskTxsWaitingForSignatures = rlpList.size() / 2;
 
-        int ntxs = rlpList.size() / 2;
-
-        for (int k = 0; k < ntxs; k++) {
-            Keccak256 hash = new Keccak256(rlpList.get(k * 2).getRLPData());
-            byte[] payload = rlpList.get(k * 2 + 1).getRLPData();
-            BtcTransaction tx;
-            if (!noInputsTxs) {
-                tx = new BtcTransaction(networkParameters, payload);
-            } else {
-                tx = new BtcTransaction(networkParameters);
-                tx.parseNoInputs(payload);
-            }
-            map.put(hash, tx);
+        for (int k = 0; k < numberOfRskTxsWaitingForSignatures; k++) {
+            Map.Entry<Keccak256, BtcTransaction> rskTxWaitingForSignaturesEntry =
+                deserializeRskTxWaitingForSignaturesEntry(rlpList, k, networkParameters);
+
+            rskTxsWaitingForSignaturesMap.put(rskTxWaitingForSignaturesEntry.getKey(), rskTxWaitingForSignaturesEntry.getValue());
         }
 
-        return map;
+        return rskTxsWaitingForSignaturesMap;
+    }
+
+    private static Map.Entry<Keccak256, BtcTransaction> deserializeRskTxWaitingForSignaturesEntry(
+            RLPList rlpList, int index, NetworkParameters networkParameters) {
+
+        RLPElement rskTxHashRLPElement = rlpList.get(index * 2);
+        byte[] rskTxHashData = rskTxHashRLPElement.getRLPData();
+        Keccak256 rskTxHash = deserializeRskTxHashFromHashData(rskTxHashData);
+
+        RLPElement btcTxRLPElement = rlpList.get(index * 2 + 1);
+        byte[] btcRawTx = btcTxRLPElement.getRLPData();
+        BtcTransaction btcTx = deserializeBtcTransactionWithInputsFromRawTx(btcRawTx, networkParameters);
+
+        return new AbstractMap.SimpleEntry<>(rskTxHash, btcTx);
     }
 
     public static byte[] serializeUTXOList(List<UTXO> list) {
@@ -145,37 +238,6 @@ public static List<UTXO> deserializeUTXOList(byte[] data) {
         return list;
     }
 
-    public static byte[] serializeSet(SortedSet<Sha256Hash> set) {
-        int nhashes = set.size();
-
-        byte[][] bytes = new byte[nhashes][];
-        int n = 0;
-
-        for (Sha256Hash hash : set) {
-            bytes[n++] = RLP.encodeElement(hash.getBytes());
-        }
-
-        return RLP.encodeList(bytes);
-    }
-
-    public static SortedSet<Sha256Hash> deserializeSet(byte[] data) {
-        SortedSet<Sha256Hash> set = new TreeSet<>();
-
-        if (data == null || data.length == 0) {
-            return set;
-        }
-
-        RLPList rlpList = (RLPList)RLP.decode2(data).get(0);
-
-        int nhashes = rlpList.size();
-
-        for (int k = 0; k < nhashes; k++) {
-            set.add(Sha256Hash.wrap(rlpList.get(k).getRLPData()));
-        }
-
-        return set;
-    }
-
     public static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map) {
         byte[][] bytes = new byte[map.size() * 2][];
         int n = 0;
@@ -604,7 +666,8 @@ private static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueueWit
             byte[] addressBytes = rlpList.get(k * 3).getRLPData();
             Address address = new Address(networkParameters, addressBytes);
             long amount = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 3 + 1).getRLPData()).longValue();
-            Keccak256 txHash = new Keccak256(rlpList.get(k * 3 + 2).getRLPData());
+
+            Keccak256 txHash = deserializeRskTxHashFromHashData(rlpList.get(k * 3 + 2).getRLPData());
 
             entries.add(new ReleaseRequestQueue.Entry(address, Coin.valueOf(amount), txHash));
         }
@@ -628,7 +691,7 @@ public static byte[] serializePegoutsWaitingForConfirmations(PegoutsWaitingForCo
         int n = 0;
 
         for (PegoutsWaitingForConfirmations.Entry entry : entries) {
-            bytes[n++] = RLP.encodeElement(entry.getBtcTransaction().bitcoinSerialize());
+            bytes[n++] = serializeBtcTransaction(entry.getBtcTransaction());
             bytes[n++] = RLP.encodeBigInteger(BigInteger.valueOf(entry.getPegoutCreationRskBlockNumber()));
         }
 
@@ -643,9 +706,9 @@ public static byte[] serializePegoutsWaitingForConfirmationsWithTxHash(PegoutsWa
         int n = 0;
 
         for (PegoutsWaitingForConfirmations.Entry entry : entries) {
-            bytes[n++] = RLP.encodeElement(entry.getBtcTransaction().bitcoinSerialize());
+            bytes[n++] = serializeBtcTransaction(entry.getBtcTransaction());
             bytes[n++] = RLP.encodeBigInteger(BigInteger.valueOf(entry.getPegoutCreationRskBlockNumber()));
-            bytes[n++] = RLP.encodeElement(entry.getPegoutCreationRskTxHash().getBytes());
+            bytes[n++] = serializeRskTxHash(entry.getPegoutCreationRskTxHash());
         }
 
         return RLP.encodeList(bytes);
@@ -697,7 +760,7 @@ private static PegoutsWaitingForConfirmations deserializePegoutWaitingForConfirm
             BtcTransaction tx =  new BtcTransaction(networkParameters, txPayload);
 
             long height = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 3 + 1).getRLPData()).longValue();
-            Keccak256 rskTxHash = new Keccak256(rlpList.get(k * 3 + 2).getRLPData());
+            Keccak256 rskTxHash = deserializeRskTxHashFromHashData(rlpList.get(k * 3 + 2).getRLPData());
 
             entries.add(new PegoutsWaitingForConfirmations.Entry(tx, height, rskTxHash));
         }
@@ -786,7 +849,7 @@ public static FlyoverFederationInformation deserializeFlyoverFederationInformati
         if (rlpList.size() != 2) {
             throw new RuntimeException(String.format("Invalid serialized Fast Bridge Federation: expected 2 value but got %d", rlpList.size()));
         }
-        Keccak256 derivationHash = new Keccak256(rlpList.get(0).getRLPData());
+        Keccak256 derivationHash = deserializeRskTxHashFromHashData(rlpList.get(0).getRLPData());
         byte[] federationP2SH = rlpList.get(1).getRLPData();
 
         return new FlyoverFederationInformation(derivationHash, federationP2SH, flyoverScriptHash);

rskj-core/src/main/java/co/rsk/peg/BridgeState.java

@@ -111,7 +111,7 @@ public Map<String, Object> stateToMap() {
     public byte[] getEncoded() throws IOException {
         byte[] rlpBtcBlockchainBestChainHeight = RLP.encodeBigInteger(BigInteger.valueOf(this.btcBlockchainBestChainHeight));
         byte[] rlpActiveFederationBtcUTXOs = RLP.encodeElement(BridgeSerializationUtils.serializeUTXOList(activeFederationBtcUTXOs));
-        byte[] rlpRskTxsWaitingForSignatures = RLP.encodeElement(BridgeSerializationUtils.serializeMap(rskTxsWaitingForSignatures));
+        byte[] rlpRskTxsWaitingForSignatures = RLP.encodeElement(BridgeSerializationUtils.serializeRskTxsWaitingForSignatures(rskTxsWaitingForSignatures));
         byte[] serializedReleaseRequestQueue = shouldUsePapyrusEncoding(this.activations) ?
                 BridgeSerializationUtils.serializeReleaseRequestQueueWithTxHash(releaseRequestQueue):
                 BridgeSerializationUtils.serializeReleaseRequestQueue(releaseRequestQueue);
@@ -133,7 +133,7 @@ public static BridgeState create(BridgeConstants bridgeConstants, byte[] data, @
         byte[] btcUTXOsBytes = rlpList.get(1).getRLPData();
         List<UTXO> btcUTXOs = BridgeSerializationUtils.deserializeUTXOList(btcUTXOsBytes);
         byte[] rskTxsWaitingForSignaturesBytes = rlpList.get(2).getRLPData();
-        SortedMap<Keccak256, BtcTransaction> rskTxsWaitingForSignatures = BridgeSerializationUtils.deserializeMap(rskTxsWaitingForSignaturesBytes, bridgeConstants.getBtcParams(), false);
+        SortedMap<Keccak256, BtcTransaction> rskTxsWaitingForSignatures = BridgeSerializationUtils.deserializeRskTxsWaitingForSignatures(rskTxsWaitingForSignaturesBytes, bridgeConstants.getBtcParams());
         byte[] releaseRequestQueueBytes = rlpList.get(3).getRLPData();
         ReleaseRequestQueue releaseRequestQueue = new ReleaseRequestQueue(BridgeSerializationUtils.deserializeReleaseRequestQueue(releaseRequestQueueBytes, bridgeConstants.getBtcParams(), shouldUsePapyrusEncoding(activations)));
         byte[] pegoutsWaitingForConfirmationsBytes = rlpList.get(4).getRLPData();

rskj-core/src/main/java/co/rsk/peg/BridgeStorageIndexKey.java

@@ -22,6 +22,11 @@ public enum BridgeStorageIndexKey {
     FAST_BRIDGE_FEDERATION_INFORMATION("fastBridgeFederationInformation"),
 
     PEGOUT_TX_SIG_HASH("pegoutTxSigHash"),
+
+    SVP_FUND_TX_HASH_UNSIGNED("svpFundTxHashUnsigned"),
+    SVP_FUND_TX_SIGNED("svpFundTxSigned"),
+    SVP_SPEND_TX_HASH_UNSIGNED("svpSpendTxHashUnsigned"),
+    SVP_SPEND_TX_WAITING_FOR_SIGNATURES("svpSpendTxWaitingForSignatures"),
     ;
 
     private final String key;