Electrum: do not persist transaction locks

eclair-core/src/main/scala/fr/acinq/eclair/blockchain/electrum/db/sqlite/SqliteWalletDb.scala

@@ -211,7 +211,7 @@ object SqliteWalletDb {
       ("history" | historyCodec) ::
       ("proofs" | proofsCodec) ::
       ("pendingTransactions" | listOfN(uint16, txCodec)) ::
-      ("locks" | setCodec(txCodec))).as[PersistentData]
+      ("locks" | provide(Set.empty[Transaction]))).as[PersistentData]
 
   def serialize(data: PersistentData): Array[Byte] = persistentDataCodec.encode(data).require.toByteArray
 

eclair-core/src/test/scala/fr/acinq/eclair/blockchain/electrum/db/sqlite/SqliteWalletDbSpec.scala

@@ -17,11 +17,16 @@
 package fr.acinq.eclair.blockchain.electrum.db.sqlite
 
 import fr.acinq.bitcoin.{Block, BlockHeader, OutPoint, Satoshi, Transaction, TxIn, TxOut}
-import fr.acinq.eclair.TestConstants
+import fr.acinq.eclair.{TestConstants, randomBytes, randomBytes32}
 import fr.acinq.eclair.blockchain.electrum.ElectrumClient
 import fr.acinq.eclair.blockchain.electrum.ElectrumClient.GetMerkleResponse
 import fr.acinq.eclair.blockchain.electrum.ElectrumWallet.PersistentData
+import fr.acinq.eclair.blockchain.electrum.db.sqlite.SqliteWalletDb.version
+import fr.acinq.eclair.wire.ChannelCodecs.txCodec
 import org.scalatest.FunSuite
+import scodec.Codec
+import scodec.bits.BitVector
+import scodec.codecs.{constant, listOfN, provide, uint16}
 
 import scala.util.Random
 
@@ -34,6 +39,36 @@ class SqliteWalletDbSpec extends FunSuite {
     if (acc.size == n) acc else makeHeaders(n, acc :+ makeChildHeader(acc.last))
   }
 
+  def randomTransaction = Transaction(version = 2,
+    txIn = TxIn(OutPoint(randomBytes32, random.nextInt(100)), signatureScript = Nil, sequence = TxIn.SEQUENCE_FINAL) :: Nil,
+    txOut = TxOut(Satoshi(random.nextInt(10000000)), randomBytes(20)) :: Nil,
+    0L
+  )
+
+  def randomHeight = if (random.nextBoolean()) random.nextInt(500000) else -1
+
+  def randomHistoryItem = ElectrumClient.TransactionHistoryItem(randomHeight, randomBytes32)
+
+  def randomHistoryItems = (0 to random.nextInt(100)).map(_ => randomHistoryItem).toList
+
+  def randomProof = GetMerkleResponse(randomBytes32, ((0 until 10).map(_ => randomBytes32)).toList, random.nextInt(100000), 0)
+
+  def randomPersistentData = {
+    val transactions = for (i <- 0 until random.nextInt(100)) yield randomTransaction
+
+    PersistentData(
+      accountKeysCount = 10,
+      changeKeysCount = 10,
+      status = (for (i <- 0 until random.nextInt(100)) yield randomBytes32 -> random.nextInt(100000).toHexString).toMap,
+      transactions = transactions.map(tx => tx.hash -> tx).toMap,
+      heights = transactions.map(tx => tx.hash -> randomHeight).toMap,
+      history = (for (i <- 0 until random.nextInt(100)) yield randomBytes32 -> randomHistoryItems).toMap,
+      proofs = (for (i <- 0 until random.nextInt(100)) yield randomBytes32 -> randomProof).toMap,
+      pendingTransactions = transactions.toList,
+      locks = (for (i <- 0 until random.nextInt(10)) yield randomTransaction).toSet
+    )
+  }
+
   test("add/get/list headers") {
     val db = new SqliteWalletDb(TestConstants.sqliteInMemory())
     val headers = makeHeaders(100)
@@ -59,46 +94,38 @@ class SqliteWalletDbSpec extends FunSuite {
 
   test("serialize persistent data") {
     val db = new SqliteWalletDb(TestConstants.sqliteInMemory())
-
-    import fr.acinq.eclair.{randomBytes, randomBytes32}
-
-    def randomTransaction = Transaction(version = 2,
-      txIn = TxIn(OutPoint(randomBytes32, random.nextInt(100)), signatureScript = Nil, sequence = TxIn.SEQUENCE_FINAL) :: Nil,
-      txOut = TxOut(Satoshi(random.nextInt(10000000)), randomBytes(20)) :: Nil,
-      0L
-    )
-
-    def randomHeight = if (random.nextBoolean()) random.nextInt(500000) else -1
-
-    def randomHistoryItem = ElectrumClient.TransactionHistoryItem(randomHeight, randomBytes32)
-
-    def randomHistoryItems = (0 to random.nextInt(100)).map(_ => randomHistoryItem).toList
-
-    def randomProof = GetMerkleResponse(randomBytes32, ((0 until 10).map(_ => randomBytes32)).toList, random.nextInt(100000), 0)
-
-    def randomPersistentData = {
-      val transactions = for (i <- 0 until random.nextInt(100)) yield randomTransaction
-
-      PersistentData(
-        accountKeysCount = 10,
-        changeKeysCount = 10,
-        status = (for (i <- 0 until random.nextInt(100)) yield randomBytes32 -> random.nextInt(100000).toHexString).toMap,
-        transactions = transactions.map(tx => tx.hash -> tx).toMap,
-        heights = transactions.map(tx => tx.hash -> randomHeight).toMap,
-        history = (for (i <- 0 until random.nextInt(100)) yield randomBytes32 -> randomHistoryItems).toMap,
-        proofs = (for (i <- 0 until random.nextInt(100)) yield randomBytes32 -> randomProof).toMap,
-        pendingTransactions = transactions.toList,
-        locks = (for (i <- 0 until random.nextInt(10)) yield randomTransaction).toSet
-      )
-    }
-
     assert(db.readPersistentData() == None)
 
     for (i <- 0 until 50) {
       val data = randomPersistentData
       db.persist(data)
       val Some(check) = db.readPersistentData()
-      assert(check === data)
+      assert(check === data.copy(locks = Set.empty[Transaction]))
+    }
+  }
+
+  test("read old persistent data") {
+    import scodec.codecs._
+    import SqliteWalletDb._
+    import fr.acinq.eclair.wire.ChannelCodecs._
+
+    val oldPersistentDataCodec: Codec[PersistentData] = (
+      ("version" | constant(BitVector.fromInt(version))) ::
+        ("accountKeysCount" | int32) ::
+        ("changeKeysCount" | int32) ::
+        ("status" | statusCodec) ::
+        ("transactions" | transactionsCodec) ::
+        ("heights" | heightsCodec) ::
+        ("history" | historyCodec) ::
+        ("proofs" | proofsCodec) ::
+        ("pendingTransactions" | listOfN(uint16, txCodec)) ::
+        ("locks" |  setCodec(txCodec))).as[PersistentData]
+
+    for (i <- 0 until 50) {
+      val data = randomPersistentData
+      val encoded = oldPersistentDataCodec.encode(data).require
+      val decoded = persistentDataCodec.decode(encoded).require.value
+      assert(decoded === data.copy(locks = Set.empty[Transaction]))
     }
   }
 }